{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3GlPu1PwwmqS"
      },
      "source": [
        "\n",
        "This colab notebook provides code and a framework for ***Lab 1 Pruning***. You can work out your solutions here.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RdC9V9xB10Gt"
      },
      "source": [
        "# **MIT 6.5940 EfficientML.ai: Lab 1 Pruning**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6BpLnUHfQ9cP"
      },
      "source": [
        "Please fill out this [feedback form](https://forms.gle/8gY5n9w1K3gddVoX9) when you finished this lab. We would love to hear your thoughts or feedback on how we can improve this lab!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2IqUbyC9YaLZ"
      },
      "source": [
        "## Goals\n",
        "\n",
        "In this assignment, you will practice pruning a classical neural network model to reduce both model size and latency. The goals of this assignment are as follows:\n",
        "\n",
        "- Understand the basic concept of **pruning**\n",
        "- Implement and apply **fine-grained pruning**\n",
        "- Implement and apply **channel pruning**\n",
        "- Get a basic understanding of performance improvement (such as speedup) from pruning\n",
        "- Understand the differences and tradeoffs between these pruning approaches"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VDkb-exkYai1"
      },
      "source": [
        "## Contents\n",
        "\n",
        "There are two main sections in this lab: ***Fine-grained Pruning*** and ***Channel Pruning***.\n",
        "\n",
        "There are ***9*** questions in total:\n",
        "- For *Fine-grained Pruning*, there are ***5*** questions (Question 1-5).\n",
        "- For *Channel Pruning*, there are ***3*** questions (Question 6-8).\n",
        "- Question 9 compares fine-grained pruning and channel pruning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2tFjnZZVlIFL"
      },
      "source": [
        "# Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W76-32bi_mHm"
      },
      "source": [
        "First, install the required packages and download the datasets and pretrained model. Here we use CIFAR10 dataset and VGG network which is the same as what we used in the Lab 0 tutorial."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "nyngBRTXQG2n"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Installing torchprofile...\n",
            "All required packages have been successfully installed!\n"
          ]
        }
      ],
      "source": [
        "print('Installing torchprofile...')\n",
        "!pip install torchprofile 1>/dev/null\n",
        "print('All required packages have been successfully installed!')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "jQb3_6zlQfib"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/home/dd/.local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
            "  from .autonotebook import tqdm as notebook_tqdm\n"
          ]
        }
      ],
      "source": [
        "import copy\n",
        "import math\n",
        "import random\n",
        "import time\n",
        "from collections import OrderedDict, defaultdict\n",
        "from typing import Union, List\n",
        "\n",
        "import numpy as np\n",
        "import torch\n",
        "from matplotlib import pyplot as plt\n",
        "from torch import nn\n",
        "from torch.optim import *\n",
        "from torch.optim.lr_scheduler import *\n",
        "from torch.utils.data import DataLoader\n",
        "from torchprofile import profile_macs\n",
        "from torchvision.datasets import *\n",
        "from torchvision.transforms import *\n",
        "from tqdm.auto import tqdm\n",
        "\n",
        "from torchprofile import profile_macs\n",
        "\n",
        "assert torch.cuda.is_available(), \\\n",
        "\"The current runtime does not have CUDA support.\" \\\n",
        "\"Please go to menu bar (Runtime - Change runtime type) and select GPU\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "yCjLyoR10Eib"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7fe78c127b30>"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "random.seed(0)\n",
        "np.random.seed(0)\n",
        "torch.manual_seed(0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "PYvLYMPC1Hel"
      },
      "outputs": [],
      "source": [
        "def download_url(url, model_dir='.', overwrite=False):\n",
        "    import os, sys, ssl\n",
        "    from urllib.request import urlretrieve\n",
        "    ssl._create_default_https_context = ssl._create_unverified_context\n",
        "    target_dir = url.split('/')[-1]\n",
        "    model_dir = os.path.expanduser(model_dir)\n",
        "    try:\n",
        "        if not os.path.exists(model_dir):\n",
        "            os.makedirs(model_dir)\n",
        "        model_dir = os.path.join(model_dir, target_dir)\n",
        "        cached_file = model_dir\n",
        "        if not os.path.exists(cached_file) or overwrite:\n",
        "            sys.stderr.write('Downloading: \"{}\" to {}\\n'.format(url, cached_file))\n",
        "            urlretrieve(url, cached_file)\n",
        "        return cached_file\n",
        "    except Exception as e:\n",
        "        # remove lock file so download can be executed next time.\n",
        "        os.remove(os.path.join(model_dir, 'download.lock'))\n",
        "        sys.stderr.write('Failed to download from url %s' % url + '\\n' + str(e) + '\\n')\n",
        "        return None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "54K1dJOx1JYZ"
      },
      "outputs": [],
      "source": [
        "class VGG(nn.Module):\n",
        "  ARCH = [64, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']\n",
        "\n",
        "  def __init__(self) -> None:\n",
        "    super().__init__()\n",
        "\n",
        "    layers = []\n",
        "    counts = defaultdict(int)\n",
        "\n",
        "    def add(name: str, layer: nn.Module) -> None:\n",
        "      layers.append((f\"{name}{counts[name]}\", layer))\n",
        "      counts[name] += 1\n",
        "\n",
        "    in_channels = 3\n",
        "    for x in self.ARCH:\n",
        "      if x != 'M':\n",
        "        # conv-bn-relu\n",
        "        add(\"conv\", nn.Conv2d(in_channels, x, 3, padding=1, bias=False))\n",
        "        add(\"bn\", nn.BatchNorm2d(x))\n",
        "        add(\"relu\", nn.ReLU(True))\n",
        "        in_channels = x\n",
        "      else:\n",
        "        # maxpool\n",
        "        add(\"pool\", nn.MaxPool2d(2))\n",
        "\n",
        "    self.backbone = nn.Sequential(OrderedDict(layers))\n",
        "    self.classifier = nn.Linear(512, 10)\n",
        "\n",
        "  def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "    # backbone: [N, 3, 32, 32] => [N, 512, 2, 2]\n",
        "    x = self.backbone(x)\n",
        "\n",
        "    # avgpool: [N, 512, 2, 2] => [N, 512]\n",
        "    x = x.mean([2, 3])\n",
        "\n",
        "    # classifier: [N, 512] => [N, 10]\n",
        "    x = self.classifier(x)\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "FI49lOle1KuL"
      },
      "outputs": [],
      "source": [
        "def train(\n",
        "  model: nn.Module,\n",
        "  dataloader: DataLoader,\n",
        "  criterion: nn.Module,\n",
        "  optimizer: Optimizer,\n",
        "  scheduler: LambdaLR,\n",
        "  callbacks = None\n",
        ") -> None:\n",
        "  model.train()\n",
        "\n",
        "  for inputs, targets in tqdm(dataloader, desc='train', leave=False):\n",
        "    # Move the data from CPU to GPU\n",
        "    inputs = inputs.cuda()\n",
        "    targets = targets.cuda()\n",
        "\n",
        "    # Reset the gradients (from the last iteration)\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "    # Forward inference\n",
        "    outputs = model(inputs)\n",
        "    loss = criterion(outputs, targets)\n",
        "\n",
        "    # Backward propagation\n",
        "    loss.backward()\n",
        "\n",
        "    # Update optimizer and LR scheduler\n",
        "    optimizer.step()\n",
        "    scheduler.step()\n",
        "\n",
        "    if callbacks is not None:\n",
        "        for callback in callbacks:\n",
        "            callback()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "bCSnuQVKidfZ"
      },
      "outputs": [],
      "source": [
        "@torch.inference_mode()\n",
        "def evaluate(\n",
        "  model: nn.Module,\n",
        "  dataloader: DataLoader,\n",
        "  verbose=True,\n",
        ") -> float:\n",
        "  model.eval()\n",
        "\n",
        "  num_samples = 0\n",
        "  num_correct = 0\n",
        "\n",
        "  for inputs, targets in tqdm(dataloader, desc=\"eval\", leave=False,\n",
        "                              disable=not verbose):\n",
        "    # Move the data from CPU to GPU\n",
        "    inputs = inputs.cuda()\n",
        "    targets = targets.cuda()\n",
        "\n",
        "    # Inference\n",
        "    outputs = model(inputs)\n",
        "\n",
        "    # Convert logits to class indices\n",
        "    outputs = outputs.argmax(dim=1)\n",
        "\n",
        "    # Update metrics\n",
        "    num_samples += targets.size(0)\n",
        "    num_correct += (outputs == targets).sum()\n",
        "\n",
        "  return (num_correct / num_samples * 100).item()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBBKNhKNlAwE"
      },
      "source": [
        "Helper Functions (Flops, Model Size calculation, etc.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "mRdK_ThzlMxL"
      },
      "outputs": [],
      "source": [
        "def get_model_macs(model, inputs) -> int:\n",
        "    return profile_macs(model, inputs)\n",
        "\n",
        "\n",
        "def get_sparsity(tensor: torch.Tensor) -> float:\n",
        "    \"\"\"\n",
        "    calculate the sparsity of the given tensor\n",
        "        sparsity = #zeros / #elements = 1 - #nonzeros / #elements\n",
        "    \"\"\"\n",
        "    return 1 - float(tensor.count_nonzero()) / tensor.numel()\n",
        "\n",
        "\n",
        "def get_model_sparsity(model: nn.Module) -> float:\n",
        "    \"\"\"\n",
        "    calculate the sparsity of the given model\n",
        "        sparsity = #zeros / #elements = 1 - #nonzeros / #elements\n",
        "    \"\"\"\n",
        "    num_nonzeros, num_elements = 0, 0\n",
        "    for param in model.parameters():\n",
        "        num_nonzeros += param.count_nonzero()\n",
        "        num_elements += param.numel()\n",
        "    return 1 - float(num_nonzeros) / num_elements\n",
        "\n",
        "def get_num_parameters(model: nn.Module, count_nonzero_only=False) -> int:\n",
        "    \"\"\"\n",
        "    calculate the total number of parameters of model\n",
        "    :param count_nonzero_only: only count nonzero weights\n",
        "    \"\"\"\n",
        "    num_counted_elements = 0\n",
        "    for param in model.parameters():\n",
        "        if count_nonzero_only:\n",
        "            num_counted_elements += param.count_nonzero()\n",
        "        else:\n",
        "            num_counted_elements += param.numel()\n",
        "    return num_counted_elements\n",
        "\n",
        "\n",
        "def get_model_size(model: nn.Module, data_width=32, count_nonzero_only=False) -> int:\n",
        "    \"\"\"\n",
        "    calculate the model size in bits\n",
        "    :param data_width: #bits per element\n",
        "    :param count_nonzero_only: only count nonzero weights\n",
        "    \"\"\"\n",
        "    return get_num_parameters(model, count_nonzero_only) * data_width\n",
        "\n",
        "Byte = 8\n",
        "KiB = 1024 * Byte\n",
        "MiB = 1024 * KiB\n",
        "GiB = 1024 * MiB"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FtPpHs2blEqt"
      },
      "source": [
        "Define misc functions for verification."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "NLYqk61hlEyZ"
      },
      "outputs": [],
      "source": [
        "def test_fine_grained_prune(\n",
        "    test_tensor=torch.tensor([[-0.46, -0.40, 0.39, 0.19, 0.37],\n",
        "                              [0.00, 0.40, 0.17, -0.15, 0.16],\n",
        "                              [-0.20, -0.23, 0.36, 0.25, 0.03],\n",
        "                              [0.24, 0.41, 0.07, 0.13, -0.15],\n",
        "                              [0.48, -0.09, -0.36, 0.12, 0.45]]),\n",
        "    test_mask=torch.tensor([[True, True, False, False, False],\n",
        "                            [False, True, False, False, False],\n",
        "                            [False, False, False, False, False],\n",
        "                            [False, True, False, False, False],\n",
        "                            [True, False, False, False, True]]),\n",
        "    target_sparsity=0.75, target_nonzeros=None):\n",
        "    def plot_matrix(tensor, ax, title):\n",
        "        ax.imshow(tensor.cpu().numpy() == 0, vmin=0, vmax=1, cmap='tab20c')\n",
        "        ax.set_title(title)\n",
        "        ax.set_yticklabels([])\n",
        "        ax.set_xticklabels([])\n",
        "        for i in range(tensor.shape[1]):\n",
        "            for j in range(tensor.shape[0]):\n",
        "                text = ax.text(j, i, f'{tensor[i, j].item():.2f}',\n",
        "                                ha=\"center\", va=\"center\", color=\"k\")\n",
        "\n",
        "    test_tensor = test_tensor.clone()\n",
        "    fig, axes = plt.subplots(1,2, figsize=(6, 10))\n",
        "    ax_left, ax_right = axes.ravel()\n",
        "    plot_matrix(test_tensor, ax_left, 'dense tensor')\n",
        "\n",
        "    sparsity_before_pruning = get_sparsity(test_tensor)\n",
        "    mask = fine_grained_prune(test_tensor, target_sparsity)\n",
        "    sparsity_after_pruning = get_sparsity(test_tensor)\n",
        "    sparsity_of_mask = get_sparsity(mask)\n",
        "\n",
        "    plot_matrix(test_tensor, ax_right, 'sparse tensor')\n",
        "    fig.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "    print('* Test fine_grained_prune()')\n",
        "    print(f'    target sparsity: {target_sparsity:.2f}')\n",
        "    print(f'        sparsity before pruning: {sparsity_before_pruning:.2f}')\n",
        "    print(f'        sparsity after pruning: {sparsity_after_pruning:.2f}')\n",
        "    print(f'        sparsity of pruning mask: {sparsity_of_mask:.2f}')\n",
        "\n",
        "    if target_nonzeros is None:\n",
        "        if test_mask.equal(mask):\n",
        "            print('* Test passed.')\n",
        "        else:\n",
        "            print('* Test failed.')\n",
        "    else:\n",
        "        if mask.count_nonzero() == target_nonzeros:\n",
        "            print('* Test passed.')\n",
        "        else:\n",
        "            print('* Test failed.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kx48A6hRhXxB"
      },
      "source": [
        "Load the pretrained model and the CIFAR-10 dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "y-C55wY2nHLT"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Downloading: \"https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth\" to ./vgg.cifar.pretrained.pth\n",
            "/tmp/ipykernel_2943425/3977767905.py:2: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  checkpoint = torch.load(download_url(checkpoint_url), map_location=\"cpu\")\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "=> loading checkpoint 'https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth'\n"
          ]
        }
      ],
      "source": [
        "checkpoint_url = \"https://hanlab18.mit.edu/files/course/labs/vgg.cifar.pretrained.pth\"\n",
        "checkpoint = torch.load(download_url(checkpoint_url), map_location=\"cpu\")\n",
        "model = VGG().cuda()\n",
        "print(f\"=> loading checkpoint '{checkpoint_url}'\")\n",
        "model.load_state_dict(checkpoint['state_dict'])\n",
        "recover_model = lambda: model.load_state_dict(checkpoint['state_dict'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "ZxBWrQIeoSu6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar10/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 170498071/170498071 [05:08<00:00, 552606.46it/s] \n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Extracting data/cifar10/cifar-10-python.tar.gz to data/cifar10\n",
            "Files already downloaded and verified\n"
          ]
        }
      ],
      "source": [
        "image_size = 32\n",
        "transforms = {\n",
        "    \"train\": Compose([\n",
        "        RandomCrop(image_size, padding=4),\n",
        "        RandomHorizontalFlip(),\n",
        "        ToTensor(),\n",
        "    ]),\n",
        "    \"test\": ToTensor(),\n",
        "}\n",
        "dataset = {}\n",
        "for split in [\"train\", \"test\"]:\n",
        "  dataset[split] = CIFAR10(\n",
        "    root=\"data/cifar10\",\n",
        "    train=(split == \"train\"),\n",
        "    download=True,\n",
        "    transform=transforms[split],\n",
        "  )\n",
        "dataloader = {}\n",
        "for split in ['train', 'test']:\n",
        "  dataloader[split] = DataLoader(\n",
        "    dataset[split],\n",
        "    batch_size=512,\n",
        "    shuffle=(split == 'train'),\n",
        "    num_workers=0,\n",
        "    pin_memory=True,\n",
        "  )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjESsg5nkdBG"
      },
      "source": [
        "# Let's First Evaluate the Accuracy and Model Size of Dense Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mMjz8MHjZRLg"
      },
      "source": [
        "Neural networks have become ubiquitous in many applications. Here we have loaded a pretrained VGG model for classifying images in CIFAR10 dataset.\n",
        "\n",
        "Let's first evaluate the accuracy and model size of this model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "DTiA8hxMkkbU"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                     "
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "dense model has accuracy=92.95%\n",
            "dense model has size=35.20 MiB\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r"
          ]
        }
      ],
      "source": [
        "dense_model_accuracy = evaluate(model, dataloader['test'])\n",
        "dense_model_size = get_model_size(model)\n",
        "print(f\"dense model has accuracy={dense_model_accuracy:.2f}%\")\n",
        "print(f\"dense model has size={dense_model_size/MiB:.2f} MiB\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-Oj8IYkxKst"
      },
      "source": [
        "While large neural networks are very powerful, their size consumes considerable storage, memory bandwidth, and computational resources.\n",
        "As we can see from the results above, a model for the task as simple as classifying $32\\times32$ images into 10 classes can be as large as 35 MiB.\n",
        "For embedded mobile applications, these resource demands become prohibitive."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "05ebw8KW1wDj"
      },
      "source": [
        "Therefore, neural network pruning is exploited to facilitates storage and transmission of mobile applications incorporating DNNs.\n",
        "\n",
        "The goal of pruning is to reduce the model size while maintaining the accuracy."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9EtFfSfCumT6"
      },
      "source": [
        "# Let's see the distribution of weight values"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0LNx2qCtZFlh"
      },
      "source": [
        "Before we jump into pruning, let's see the distribution of weight values in the dense model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "qg2rkEo8umkb"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x600 with 9 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def plot_weight_distribution(model, bins=256, count_nonzero_only=False):\n",
        "    fig, axes = plt.subplots(3,3, figsize=(10, 6))\n",
        "    axes = axes.ravel()\n",
        "    plot_index = 0\n",
        "    for name, param in model.named_parameters():\n",
        "        if param.dim() > 1:\n",
        "            ax = axes[plot_index]\n",
        "            if count_nonzero_only:\n",
        "                param_cpu = param.detach().view(-1).cpu()\n",
        "                param_cpu = param_cpu[param_cpu != 0].view(-1)\n",
        "                ax.hist(param_cpu, bins=bins, density=True,\n",
        "                        color = 'blue', alpha = 0.5)\n",
        "            else:\n",
        "                ax.hist(param.detach().view(-1).cpu(), bins=bins, density=True,\n",
        "                        color = 'blue', alpha = 0.5)\n",
        "            ax.set_xlabel(name)\n",
        "            ax.set_ylabel('density')\n",
        "            plot_index += 1\n",
        "    fig.suptitle('Histogram of Weights')\n",
        "    fig.tight_layout()\n",
        "    fig.subplots_adjust(top=0.925)\n",
        "    plt.show()\n",
        "\n",
        "plot_weight_distribution(model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4gRkueJTY0hL"
      },
      "source": [
        "## Question 1 (10 pts)\n",
        "\n",
        "Please answer the following questions using the information in the above histograms of weights."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LrKtD5x6AGYt"
      },
      "source": [
        "\n",
        "### Question 1.1 (5 pts)\n",
        "\n",
        "What are the common characteristics of the weight distribution in the different layers?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "klj92pzBcvaI"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5eIrHzR__ir"
      },
      "source": [
        "### Question 1.2  (5 pts)\n",
        "\n",
        "How do these characteristics help pruning?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DD5lzMoAABdO"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USisw8QcnPNP"
      },
      "source": [
        "# Fine-grained Pruning"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkeZm_NJZ0NM"
      },
      "source": [
        "In this section, we will implement and perform fine-grained pruning.\n",
        "\n",
        "Fine-grained pruning removes the synapses with lowest importance. The weight tensor $W$ will become sparse after fine-grained pruning, which can be described with **sparsity**:\n",
        "\n",
        "> $\\mathrm{sparsity} := \\#\\mathrm{Zeros} / \\#W = 1 - \\#\\mathrm{Nonzeros} / \\#W$\n",
        "\n",
        "where $\\#W$ is the number of elements in $W$.\n",
        "\n",
        "In practice, given the target sparsity $s$, the weight tensor $W$ is multiplied with a binary mask $M$ to disregard removed weight:\n",
        "\n",
        "> $v_{\\mathrm{thr}} = \\texttt{kthvalue}(Importance, \\#W \\cdot s)$\n",
        ">\n",
        "> $M = Importance > v_{\\mathrm{thr}}$\n",
        ">\n",
        "> $W = W \\cdot M$\n",
        "\n",
        "where $Importance$ is importance tensor with the same shape of $W$, $\\texttt{kthvalue}(X, k)$ finds the $k$-th smallest value of tensor $X$, $v_{\\mathrm{thr}}$ is the threshold value."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qajrblu0Is3z"
      },
      "source": [
        "## Magnitude-based Pruning\n",
        "\n",
        "For fine-grained pruning, a widely-used importance is the magnitude of weight value, *i.e.*,\n",
        "\n",
        "$Importance=|W|$\n",
        "\n",
        "This is known as **Magnitude-based Pruning** (see [Learning both Weights and Connections for Efficient\n",
        "Neural Networks](https://arxiv.org/pdf/1506.02626.pdf))."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r9nTCaD8wxvA"
      },
      "source": [
        "![pruning.png]()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZpAlUYwc7U-"
      },
      "source": [
        "### Question 2 (15 pts)\n",
        "\n",
        "Please complete the following magnitude-based fine-grained pruning function.\n",
        "\n",
        "**Hint**:\n",
        "*   In step 1, we calculate the number of zeros (`num_zeros`) after pruning. Note that `num_zeros` should be an integer. You could use either `round()` or `int()` to convert a floating number into an integer. Here we use `round()`.\n",
        "*   In step 2, we calculate the `importance` of weight tensor. Pytorch provides [`torch.abs()`](https://pytorch.org/docs/stable/generated/torch.abs.html#torch.abs), [`torch.Tensor.abs()`](https://pytorch.org/docs/stable/generated/torch.Tensor.abs.html#torch.Tensor.abs), [`torch.Tensor.abs_()`](https://pytorch.org/docs/stable/generated/torch.Tensor.abs_.html) APIs.\n",
        "*   In step 3, we calculate the pruning `threshold` so that all synapses with importance smaller than `threshold` will be removed. Pytorch provides [`torch.kthvalue()`](https://pytorch.org/docs/stable/generated/torch.kthvalue.html), [`torch.Tensor.kthvalue()`](https://pytorch.org/docs/stable/generated/torch.Tensor.kthvalue.html), [`torch.topk()`](https://pytorch.org/docs/stable/generated/torch.topk.html) APIs.\n",
        "*   In step 4, we calculate the pruning `mask` based on the `threshold`. **1** in the `mask` indicates the synapse will be kept, and **0** in the `mask` indicates the synapse will be removed. `mask = importance > threshold`. Pytorch provides [`torch.gt()`](https://pytorch.org/docs/stable/generated/torch.gt.html?highlight=torch%20gt#torch.gt) API."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "3n6g76DPnXFz"
      },
      "outputs": [],
      "source": [
        "def fine_grained_prune(tensor: torch.Tensor, sparsity: float) -> torch.Tensor:\n",
        "    \"\"\"\n",
        "    magnitude-based pruning for single tensor\n",
        "    :param tensor: torch.(cuda.)Tensor, weight of conv/fc layer\n",
        "    :param sparsity: float, pruning sparsity\n",
        "        sparsity = #zeros / #elements = 1 - #nonzeros / #elements\n",
        "    :return:\n",
        "        torch.(cuda.)Tensor, mask for zeros\n",
        "    \"\"\"\n",
        "    # 限制稀疏率在 [0, 1] 范围内\n",
        "    sparsity = min(max(0.0, sparsity), 1.0)\n",
        "\n",
        "    # 当稀疏率为 1 时，返回全零张量\n",
        "    if sparsity == 1.0:\n",
        "        tensor.zero_()\n",
        "        return torch.zeros_like(tensor)\n",
        "    # 当稀疏率为 0 时，返回全 1 的张量\n",
        "    elif sparsity == 0.0:\n",
        "        return torch.ones_like(tensor)\n",
        "\n",
        "    # Step 1: 计算总元素数量和需要剪枝的元素数量\n",
        "    num_elements = tensor.numel()\n",
        "    num_zeros = round(sparsity * num_elements)\n",
        "\n",
        "    # Step 2: 计算权重的绝对值，以此作为权重的重要性\n",
        "    importance = tensor.abs().flatten()\n",
        "\n",
        "    # Step 3: 计算剪枝阈值（即取绝对值后的前 num_zeros 小的值作为阈值）\n",
        "    threshold = torch.topk(importance, num_zeros, largest=False).values.max()\n",
        "\n",
        "    # Step 4: 获取二进制掩码，大于阈值的为 1，否则为 0\n",
        "    mask = (tensor.abs() > threshold).float()\n",
        "\n",
        "    # Step 5: 应用掩码对张量进行剪枝\n",
        "    tensor.mul_(mask)\n",
        "\n",
        "    return mask"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZQy75p5iB0QC"
      },
      "source": [
        "Let's verify the functionality of defined fine-grained pruning by applying the function above on a dummy tensor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "tqKLOsLdihcX"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 600x1000 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "* Test fine_grained_prune()\n",
            "    target sparsity: 0.75\n",
            "        sparsity before pruning: 0.04\n",
            "        sparsity after pruning: 0.76\n",
            "        sparsity of pruning mask: 0.76\n",
            "* Test passed.\n"
          ]
        }
      ],
      "source": [
        "test_fine_grained_prune()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9GdyRrweym49"
      },
      "source": [
        "### Question 3 (5 pts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YxQyShwLylw4"
      },
      "source": [
        "The last cell plots the tensor before and after pruning. Nonzeros are rendered in blue while zeros are rendered in gray. Please modify the value of `target_sparsity` in the following code cell so that there are only 10 nonzeros in the sparse tensor after pruning."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "E5Q3jj6YArPa"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAE/CAYAAABb+PcPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABG70lEQVR4nO3deXhTZdoG8Dtbs3dL17ShLWlLW1YBQRFURIQRcRAYxVFEUUDFhcFt8JtRGUcWR3EXRBRBxwVZHDcWEVxAxIWtCLKVlm50J226ZD3fH5VgaEtP2yQt8f559brIyXvevE/S3H1ychIlgiAIICIiIqJzknb2AoiIiIjOB2yaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJq6uCeeeAISiaSzl0FERPSHx6aJAmLevHn46KOPOnsZRERemE3UFmyaKCAYTETUFTGbqC3YNBG1gSAIqK+v7+xlEAU1p9MJu93e2cs4rzCbAoNNUxeybds2XHjhhVCpVDCbzXjttddaHPvOO+9gwIABUKvViIyMxKRJk5Cfn+815vLLL0evXr1w4MABDB8+HBqNBgkJCXj66aebzPfSSy+hZ8+e0Gg0iIiIwMCBA/Huu+96jSksLMTUqVMRGxsLpVKJnj174s0332y1LolEgtraWqxYsQISiQQSiQS33nprm+b96quvIJFIsGrVKjz11FNITEyESqXCiBEjcPToUa+xR44cwYQJExAXFweVSoXExERMmjQJFovFM8bpdOLJJ5+E2WyGUqlEcnIyHn30UdhsNq+5kpOTcc0112Djxo0YOHAg1Gr1OR8XovNZTU0NZs2aheTkZCiVSsTExGDkyJHYtWuXZ8zpXPn5558xZMgQqNVqpKSkYMmSJV5z2e12PPbYYxgwYADCwsKg1WoxbNgwbN261Wtcbm4uJBIJnnnmGTz//POe5+SBAwcAMJuYTV2LRBAEobMXQUB2djYGDx6M6Oho3HXXXXA6nXj55ZcRGxuLffv24fcP01NPPYV//vOfuP7663HZZZehrKwML730EnQ6HXbv3o3w8HAAjeF25MgRyGQyjB8/Hj169MDq1auxZcsWfP755/jTn/4EAHj99dcxffp0TJw4ESNHjkRDQwP27dsHrVaLF154AQBQUlKCgQMHQiKRYNq0aYiOjsb69evx8ccf47nnnsOsWbNarO2dd97BHXfcgUGDBmH69OkAALPZjIsvvlj0vF999RWGDx+OCy64AFKpFDfffDMsFguefvpp9OrVCzt37gTQGNQZGRmw2Wy4++67ERcXh8LCQnz66af48MMPkZSUBAC49dZbsWLFCkycOBHDhw/Hzp07sXLlSowbNw7r1q3zrD05ORkKhQIVFRWYMWMGkpOT0aNHD1x++eW+eNiJupSbbroJq1evxj333IOsrCxUVFRg27ZtuOGGG3DTTTcBOJMrTqcT119/PdLT07Fq1Sps27YNb7zxBqZOnQoAKC8vR58+fXDjjTciLS0NNTU1eOONN5CTk4MffvgB/fr1A9DYNKWkpCArKwsNDQ2YPn06lEolxo8fj40bNzKbmE1di0Bdwrhx4wSVSiXk5eV5th04cECQyWTC7x+m3NxcQSaTCU899ZTX/tnZ2YJcLvfaftlllwkAhJUrV3q22Ww2IS4uTpgwYYJn25///GehZ8+e51zf7bffLsTHxwvl5eVe2ydNmiSEhYUJdXV159xfq9UKU6ZMafe8W7duFQAImZmZgs1m84x74YUXBABCdna2IAiCsHv3bgGA8OGHH7a4lj179ggAhDvuuMNr+4MPPigAELZs2eLZlpSUJAAQNmzYcM76iIJBWFiYMHPmzHOOOZ0rzz77rGebzWYT+vXrJ8TExAh2u10QBEFwOp1ez1VBEISqqiohNjZWmDp1qmfb8ePHBQBCaGioUFpa6jWe2dSI2dR18O25LsDlcmHjxo0YN24cunXr5tmemZmJUaNGeY1du3Yt3G43rr/+epSXl3t+4uLikJaW1uTQt06nw8033+y5HBISgkGDBiEnJ8ezLTw8HAUFBfjxxx+bXZ8gCFizZg3Gjh0LQRC8bnfUqFGwWCxeh+/Fas+8t912G0JCQjyXhw0bBgCeesLCwgAAGzduRF1dXbO3+/nnnwMAZs+e7bX9gQceAAB89tlnXttTUlKaPA5EwSg8PBw7d+5EUVHROcfJ5XLMmDHDczkkJAQzZsxAaWkpfv75ZwCATCbzPFfdbjcqKyvhdDoxcODAZvNiwoQJiI6ObrIeZhOzqSth09QFlJWVob6+HmlpaU2u69Gjh9flI0eOQBAEpKWlITo62uvn4MGDKC0t9RqfmJjY5HueIiIiUFVV5bn8yCOPQKfTYdCgQUhLS8PMmTOxfft2r/WdOnUKS5cubXKbt912GwA0uV2xdbd13t83ladrAeCpJyUlBbNnz8ayZcsQFRWFUaNG4ZVXXvE6ZyAvLw9SqRSpqalec8XFxSE8PBx5eXle21NSUtpcG9H56Omnn8b+/fthMpkwaNAgPPHEE14vsE4zGo3QarVe29LT0wE0vt122ooVK9CnTx+oVCoYDAZER0fjs88+83o+ntbc84zZ1IjZ1HXIO3sB1DZutxsSiQTr16+HTCZrcr1Op/O63NwYAF7nSGVmZuLQoUP49NNPsWHDBqxZswavvvoqHnvsMcydOxdutxsAcPPNN2PKlCnNztenT5921dLWecXU8+yzz+LWW2/F//73P2zatAn33Xcf5s+fj++//x6JiYmecWK/NFStVosaR3S+u/766zFs2DCsW7cOmzZtwn/+8x8sXLgQa9eu9ZwDKdY777yDW2+9FePGjcNDDz2EmJgYyGQyzJ8/H8eOHWsyvrnnGbPp3JhNgcemqQuIjo6GWq3GkSNHmlx36NAhr8tmsxmCICAlJcXzys4XtFotbrjhBtxwww2w2+0YP348nnrqKcyZMwfR0dHQ6/VwuVy48sor2zV/cyHgi3lb0rt3b/Tu3Rv/+Mc/8N133+GSSy7BkiVL8O9//xtJSUlwu904cuQIMjMzPfuUlJTg1KlTnhMyif6I4uPjcffdd+Puu+9GaWkp+vfvj6eeesqraSoqKkJtba3X0abDhw8DaDxBGQBWr16N7t27Y+3atV7P/8cff7xN62E2MZu6Er491wXIZDKMGjUKH330EU6cOOHZfvDgQWzcuNFr7Pjx4yGTyTB37lyvVzBA4yuaioqKNt/+2fuEhIQgKysLgiDA4XBAJpNhwoQJWLNmDfbv399k/7KyslZvQ6vV4tSpU17bfDHv2aqrq+F0Or229e7dG1Kp1POR3auvvhoA8Pzzz3uNW7RoEQBgzJgxbb5dovOdy+Vq8rZZTEwMjEZjk4+7O51Or4+32+12vPbaa4iOjsaAAQMAnDny8vuc2rlzJ3bs2CF6TcymRsymroNHmrqIuXPnYsOGDRg2bBjuvvtuOJ1Oz/eT7Nu3zzPObDbj3//+N+bMmYPc3FyMGzcOer0ex48fx7p16zB9+nQ8+OCDbbrtq666CnFxcbjkkksQGxuLgwcP4uWXX8aYMWOg1+sBAAsWLMDWrVsxePBgTJs2DVlZWaisrMSuXbuwefNmVFZWnvM2BgwYgM2bN2PRokUwGo1ISUnB4MGDOzzv2bZs2YJ77rkHf/nLX5Ceng6n04m3337bE4IA0LdvX0yZMgVLly7FqVOncNlll+GHH37AihUrMG7cOAwfPrxNt0kUDGpqapCYmIiJEyeib9++0Ol02Lx5M3788Uc8++yzXmONRiMWLlyI3NxcpKen44MPPsCePXuwdOlSKBQKAMA111yDtWvX4rrrrsOYMWNw/PhxLFmyBFlZWbBaraLWxGxiNnU5gf64HrXs66+/FgYMGCCEhIQI3bt3F5YsWSI8/vjjQnMP05o1a4ShQ4cKWq1W0Gq1QkZGhjBz5kzh0KFDnjGXXXZZsx/XnTJlipCUlOS5/NprrwmXXnqpYDAYBKVSKZjNZuGhhx4SLBaL134lJSXCzJkzBZPJJCgUCiEuLk4YMWKEsHTp0lZr+/XXX4VLL71UUKvVAgCvj/iKmff0x3rP/rju6Y8rL1++XBAEQcjJyRGmTp0qmM1mQaVSCZGRkcLw4cOFzZs3e+3ncDiEuXPnCikpKYJCoRBMJpMwZ84coaGhwWtcUlKSMGbMmFbrIzrf2Ww24aGHHhL69u0r6PV6QavVCn379hVeffVVr3Gnc+Wnn34SLr74YkGlUglJSUnCyy+/7DXO7XYL8+bNE5KSkgSlUilccMEFwqefftokf04/h//zn/80WROzidnU1fDLLYmISLTLL78c5eXlzb5tRRTseE4TERERkQhsmoiIiIhEYNNEREREJALPaSIiIiISgUeaiIiIiERg00REREQkQru/3NLtdqOoqAh6vV70/yeHiAho/Jbompoa6PV6hIaGdjhDmEdE1BGnM8loNEIqbfl4UrubpqKiIphMpvbuTkQEALBYLAgNDe3QHMwjIvKF/Px8r/958tna3TSd/gr7ng+8D5lS095piOgPyGWrwy/PTkJ+fr4nSzqCeUREHXE6k1rLo3Y3TacPgcuUGshU2lZGExE15Yu35gDmERH5Rmt5xBPBiYiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR5J11w4Ig4OSWt1D+8+dwNVih7dYLprH3Q2VIFLX/yW/eQ/HmZYi+aDwSr57pdV3tiV9Q9OWbqCv4FZBKoY4zI/WWhZAqlP4opQl/1eZ22FG4cTGqsrdCcDmgT70Qpmvug0IX6a9SvJTt/Ail21fBYa2EOtaMxDH3QpuY0ezYUwe+xclv3oW9shCCywWlIQExQ/6CyH4jPWMc1koUbXod1cd+hqvBCl1SHySOuUf0/eQrbamrvjQXxVveQn3RYdhPlSBh9N2IGTLBa4zLVofiL5fj1MFtcNaegiY+FQlXz4Q2ofk5/cnXj9nux0Y0u6/xqumIHXqDX2oIBOZRy5hHgc0jIHgzKRjyqNOaptJt76Ns5zp0u+4RKCPiULzlLRxb+Xdk3vMmpIqQc+5bW/grKn76FKrY7k2vO/ELjr49B7HDbkTimHshkcpQf/IYIJH4q5Qm/FVb4YZXYTm8Eyk3PA6ZSov8T1/E8feeQPq0F/1VikdV9lYUblgC09hZ0CRmoGzHWhxb+Qgy73sLCl1Ek/EytR5xl94EVbQJEpkClkM7kPfR05BrwxGadiEEQUDOu49BIpOj+1//BZlSi9LvPsTRtx5C5r1vQhai9ntN7anL7WiAMiIeET0vRcH6xc3OeeJ/z6Kh5DiSJ8yBQm9A5d7NOPrWw8i89w2EhEb7uyQPXz9mANDroQ+99qk+8gNO/O8ZhGcNC0hN/sI8ah7zKLB51J7azpdMCpY86pS35wRBQOmOtYi99GaEZ14CdZwZSeMfgaOmHJZft51zX5etHnmr58H059mQq/VNri/YsBjRF12HuEtvhDomGaooEyJ6XQ6p/Nzh4Cv+qs3VYEXFrvVIGH0n9N0vgMaYjqTrHkZt/i+ozT/gz5IAAKXfrYZhwNUw9B8NdUwyTGNnQapQomLXhmbH61P6ITxrKFTRSVBGGhFz8QSoY7vDemI/AMBWUYC6goMwjZ0FbUIGVFEmmK6ZBcFpR1X2Fr/X0966tAkZSBg1AxG9r4BUrmhyvdthw6kD38B41XTokvtAaUhA/BVToIw0ovyHT/xdjhdfP2YAoNBHev1Yft0OXXI/KCONgSrL55hHzWMeBT6PgODNpGDJo05pmuxVxXBaK6E39/dsk6l00CZktvqEK/jsBYSmX4RQ84Am1zmsVagrOAiFNhyHX78X2Qsn4Mgbf4M1L9vnNbTEX7XVFR2B4HJC3/3MdaroblCExfg9pNxOB+qKD3vVJJFKoTf3R11B67ctCAJqju2CrbwAuqTejdtcDgDw+uMhkUohkSlQm7e/2Xl8raN1NUdwuwC3u8kfRalCidoTgakL8M9jdjaHtRKWwzthGPAnn627MzCPmsc8CmweAcGbScGUR6LfnrPZbLDZbJ7L1dXV7b5Rh7UKAJockpPrIjzXNacqewvqio6ix4xXm73eXlUMACjeugIJo+6EOt6Myj1f4OhbDyHjnmUBeW/aX7U5rJWQyBSQq3Ve2xW6CDislR1c9bm56iyA2w2F9qyatBFoKMtveb8GK/Y/cwPcTgckUilM19yP0NSBAABVVGPAFn2xDKZr/wapQoWyHavhqC6Do8a/9XjW1866zkWm1EBrysLJr9+BKrob5LoIVGVvQW3+gYAejfHHY3a2yt2bIFNqEJ4Z+LfmmEfiMI9+t18XzyMgeDMpmPJIdNM0f/58zJ07t103Url3M/I/ec5zuftN89o8h91SioLPX0HqlKdbfB9eEAQAQNTAa2DoPxoAoIlPQ03OLlTu2gDjyDvasfpzC1Rt5yNpiAYZdy2Fy16PmpxdKNywGCER8dCn9Gs8d+DGuTjx0TPInj8OkEqh7z4AoWmDPI/j+SppwhycWPcf7H/mBkAqhSY+DRG9h6Ou6EhnL61V53rMzlaxewMi+ozolN9Z5lHzmEct+6PmEXD+ZlJXzCPRTdOcOXMwe/Zsz+Xq6mqYTCZR+4ZlDIE2MdNz2f3boVCHtQoKvcGz3Wmtgjre3OwcdUWH4aw9hV+X3Hlmo9sNa94+lP3wEfo9tgEKfeOnNlQxSV77qqKTYLeUilprWwWsNl0kBJcDznqr16s7h7XK759WkWnCAKkUjlrvV6bO2irPfd4ciVQKpSEBAKCJT4Wt7ARKvnnP8wuvMaYj4+6lcDVY4XY5odCG49BrM6FJSPdbLb/X3rpao4w0Iu325+Cy18Ntq4NCb8DxVU9CGRHf0SWL5q/H7DRr7j7YyvORfP0/fb52MZhHzWMenb95BARvJgVTHolumpRKJZTK9n1EVqbUQKbUeC4LggC5LhI1ObugiU8FALgaalFbeBBRg8Y2O4e+e39kzFzmte3Euv9AGW1C7NBJkEhlCAmPg0JvQEN5gdc4W3mB52x7XwtUbRpjGiQyOaw5uxDe81IAQEN5PhyWUmhNWX6p7TSpXAFNfDpqcnYjPHMoAEBwu1GTsxtRg8aJnkcQBM+5A78nU+kgA9BQUYC6osOIH3Gbj1Z+br6qqyWyEDVkIWo462tQc/RHGK+a3uE5xfL3Y1axaz3UxnRo4pr/w+tvzKPmMY/GiZ6nq+URELyZFEx51ClfOSCRSBBz8XiUfP1fqAyJCImIQ/GXy6HQRyEsY6hn3JHlDyI8ayiiB4+DTKmBOjbFax5piApydahnu0QiQcwlN6B46wqo47pDE5eKij2b0FB+AimTHj+va5OpdDD0/xMKNiyGTK2HTKVFwWcvQWvK8ntIAUDMkInIW7cQGmM6tIkZKN2xBm57Awz9RwEActcsQEholOcth5PfvAuNMR3KSCMElwOWwztRufcLmMbe75mzav/XkGvDEBIWg/qS4yhc/wrCMi9p8T3rrlCX2+lAQ1le479dTjhqylFXfBSyELXnFVH1kR8BCFBGmWCrKETRpqVQRnWD4YLRAaurPbWJecyAxj+6p375Bgmj72xym+cj5hHzCOgaedSe2s6XTAqWPOq072mKGToJbnsDTny86LcvXOsN8+T5Xu9H2quK4Ky1tG3eIRPgdtpRuH4xXPU1UMd1R+qUpwN6Eq6/aksYfTcgkeD4B3MhOB3Qpw6E6Zr7W9/RByJ6D4ezzoLiLW81HtqPM8M8eYHnULzDUgrJ7757xm1vQMGnL8JeXQapQglVlAnJE+YgovdwzxiHtQKFGxbDWVsFuS4Skf2uQtxlNweknvbW5aipwKHFMzyXS7evQun2VdAl90Xa1EUAAJetFkVfLIOjuhwytR7hWcNgvHIqJLLAPt388ZgBQNX+rRAgNNl+PmMeMY+6Qh61p7bzJZOCJY8kQjvPcquurkZYWBj6PPoxZCqtr9dFREHM1VCLffOuhcViQWhoaIfnYx4RUUeIzST+v+eIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJIO/oBMsnJECn0/liLV3KpA8KOnsJRNRGzCMi8iceaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYkg76wb/u9//4s33ngDZWVlyMjIwD//+U/06dOnxfHr16/HCy+8gMLCQiQnJ+PBBx/EZZdd5rleEAS8+OKL+PDDD1FdXY3+/fvjiSeeQHJycgCqOaNs50co3b4KDmsl1LFmJI65F9rEjFb3q8regtwPn0JYxhB0/+uTnu2CIODklrdQ/vPncDVYoe3WC6ax90NlSPRnGc1qS231pbko3vIW6osOw36qBAmj70bMkAleY35Z9FfYT5U02Tdq0LUwXXO/X2poSXvuZ2vuPpRs+wB1xUfgrKlAyo1zEZ451GtM3tqFqNyzyWubPvVCpN6ywC91nM3XjxkA2KvLULTpdVQf+QFuhw3KyAQkXfcQNAk9/F2O3wRrHgHBm0nMI2/Mo8DkUaccafr8888xf/58zJw5E+vWrUNGRgZuv/12VFRUNDt+165deOCBBzBx4kR89NFHGDFiBGbOnInDhw97xrz++ut4++238cQTT2DVqlVQq9W4/fbbYbPZAlUWqrK3onDDEsRdfgt63LkE6jgzjq18BA5r1Tn3s1WdROHG16BN6t3kutJt76Ns5zqYxs5Cj+kvQxaiwrGVf4fbYfdXGc1qa21uRwOUEfEwjrwDcl1ks2PSZ7yKXg996PkxT3kaABDe87Jmx/tTe+5nl70e6jgzTGPuO+fc+tQLvepM/sv/+Xr5zfLHY+asr8GRZfdDIpPDPHkBMu99Ewmj74RMrfdnKX4VrHkEBG8mMY+aYh4FJo86pWlavnw5rr/+ekyYMAGpqamYO3cuVCoV1qxZ0+z4lStXYtiwYbjjjjtgNpsxa9YsZGVl4Z133gHQ2JWvXLkSd911F6688kpkZGTg6aefRmlpKTZv3hywukq/Ww3DgKth6D8a6phkmMbOglShRMWuDS3uI7hdyFs9D/HDp0AZEe99nSCgdMdaxF56M8IzL4E6zoyk8Y/AUVMOy6/b/F2Ol7bWpk3IQMKoGYjofQWkckWzYxTacCj0kZ6f6kPfIyTSCF1yX3+W0kR77+ew9MEwXjkV4VlDWxwDAFK5wqtOeYAaDH88ZiXfvg9FaDSSrnsY2sQMKCPiEZo6EMpIoz9L8atgzSMgeDOJedQU8ygweRTwpslut+OXX37BkCFDzixCKsWQIUOwe/fuZvfZs2cPLr74Yq9tQ4cOxZ49ewAABQUFKCsr85pTr9ejb9++Lc7pa26nA3XFh6E39/dsk0il0Jv7o67gQIv7nfzqbch14TAMuLrJdfaqYjitlV5zylQ6aBMyUZvf8py+1t7a2noblfs2w3DBaEgkEp/MKZa/72dr7l5kL5yAAy9MQf4nz8NZZ+nwnK3x12NWfeg7aBJ64PgHc5G9cAJ+fXUGyn/6zBdL7hTBmkdA8GYS86hjmEcdI/qcJpvN5nVoubq6ul03WFVVBZfLBYPB4LXdYDAgJyen2X3Ky8sRFRXVZHx5eTkAoKyszLOtpTH+5qqzAG43FNoIr+1ybQQayvKb3ceal42KXeuRcdfSZq8/fdhSoTtrTl1Eq4fXfak9tbWV5dftcDVYYbhglE/mawt/3s+haRciPGsYQiLiYKssQvHmN3Ds7TlIn/YSJFJZh+Y+F389ZraqYth+/BgxF09E7KV/RV3hIRR8/jIkMnlAHzvmUeuCNZOYR+3HPOo40U3T/PnzMXfuXL8s4o/IZatD3poFMF07G3JtWGcvp9NV/LweoamDoAiNan1wB1Xu3Yz8T57zXO5+0zy/3VZE7ys8/1bHdoc6tjsOPD8Z1uN7vV51nTcEARpjOowj7wAAaOLT0FCSi/IfPwnoHxjmke8xk85gHp0nOiGPRDdNc+bMwezZsz2Xq6urYTKZ2nyDERERkMlkTU6yrKioaPLq7bSoqKgmr9B+Pz46OtqzLSYmxmtMRkbrnxLxBZkmDJBK4aj1fiXgrK2CQt/0JDZbZRHsp04i591/nNkoCACA3U+MRNZ9KzyvNBzWKij0Z161Oq1VUMeb/VBF89paW1vZT5WgJmcXUiY90eG5xAjLGAJtYqbnstvlABCY+1kZaYRcEwZbZaFfQ8pfj5lcFwlVdJLXNmV0N5w68E2752wP5lHrgjWTmEe+wzxqO9HnNCmVSoSGhnr9tEdISAh69uyJHTt2eLa53W7s2LEDF1xwQbP79OvXD99//73Xtu+++w79+vUDACQmJiI6OtprTqvVir1797Y4p69J5Qpo4tNRk3PmnAXB7UZNzm5oErOajFdFdUPGzGXIuGup5yesx8XQJfdDxl1LoQiNRkhEPOS6SNTk7PLs52qoRW3hQWhNTef0l7bW1lYVuzZArg1HWPpFHZ5LDJlSA6UhwfOjik4K2P1st5TBWV/tFYb+4K/HTNetFxrKvQ+n2yoKEBIe2+4524N51LpgzSTmke8wj9quU76n6bbbbsMjjzyCXr16oU+fPlixYgXq6+sxfvx4AMDDDz+M2NhYPPDAAwCAW265BZMnT8abb76Jyy67DJ9//jn279+Pf/3rXwAAiUSCW265BYsXL0ZSUhISExPxwgsvICYmBldeeWXA6ooZMhF56xZCY0yHNjEDpTvWwG1vgKF/42HC3DULEBIaBePIOyBVhEAdm+K1v0ylAwCv7TEXj0fJ1/+FypCIkIg4FH+5HAp9FMIyzv0JCV9rS21A44l/DWV5jf92OeGoKUdd8VHIQtRQGhI88wpuNyp2b0Bkv6sgkfnvPfVzkUgkou7nI8sfRHjWUEQPHgcAcNnqYass9FxvrzqJuuKjkKv1CAmPhctWj5NfrUR41jDIdZGwVxahcNNSKCON0KcO9Htd/njMoodMwOHX78PJr/+LiF6Xo7bwV1T89BlM1/7N7/X4S7DmERC8mcQ8Yh4BnZNHndI0XX311aisrMSLL76IsrIyZGZmYtmyZZ7D28XFxZBKzxwE69+/P5555hk8//zzWLRoEZKTk/HKK68gPT3dM2batGmor6/HY489hurqagwYMADLli2DUqkMWF0RvYfDWWdB8Za3Gg+lxplhnrwAit++Y8JhKW3zJzFihk6C296AEx8v+u1LznrDPHk+pIoQf5TQorbW5qipwKHFMzyXS7evQun2VdAl90Xa1EWe7TU5u+CwlMLQf3TgimmGmPvZXlUEZ+2ZT5rUFR3C0eUPeC4XblgMAIjsdxWSxj8CiVSK+pM5qNyzCa4GKxR6A/TmgYgfcSukcv8/fv54zLQJGeh+41wUffEGTn79NkLC45Hwp7sR2TewzYAvBWseAcGbScwj5hHQOXkkEYTf3rRuo+rqaoSFheHnn3+GTqfz9bo63aQPCjp7CURBy9VQi33zroXFYmn3W2u/xzwioo4Qm0n8f88RERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQjyjk5w25pCyFRaX6yFiKhDmEdE5E880kREREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhJB3lk3LAgCTm55C+U/fw5XgxXabr1gGns/VIbEFvc5+c27sBzYhobyE5AqlNCasmC8ajpUUSbPGLfDjsKNi1GVvRWCywF96oUwXXMfFLrIQJQFwH+1nfh4EWqO7YKjpgKyEDW03XrCOHIaVNHdAlEWynZ+hNLtq+CwVkIda0bimHuhTcxoduypA9/i5Dfvwl5ZCMHlgtKQgJghf0Fkv5Fe4xrK8lC46XVYc/cBbhdU0UlImfQ4QsJjA1ESgLbVVf7TZ6jcswkNpbkAALUxHcYrb/can7d2ISr3bPLaT596IVJvWeC3GlrSltoAoGr/1yjeshz2UyehjEyE8appCEsf7Lm+eMsKVO3fCoelDBKZvLH+EVOhNWUGohy/YR55Yx51Xh4BwZtJwZBHEkEQhPbsWF1djbCwMPR59GPIVNo271/y7Xso+fY9dLvuESgj4lC85S3UlxxH5j1vQqoIaXafoyv/jojel0OTkAHB7ULxF2+gvvQ4Mu99E7IQNQAg/5PnYTm8E0nXPQyZSov8T1+ERCJF+rQX21Nmu/irtvKfPoUqqhsUYTFw1VejeOtK1J88hp5/ewcSqcyvNVVlb0Xe2oUwjZ0FTWIGynasxalfvkbmfW9BoYtoMr7m+B646q1QRZsgkSlgObQDhRuXwHzTPISmXQgAsFUW4dBrd8PQ/0+I6HMFZEotGkpzoUnMbHbOrlBX7up50HbrCa2pJ6TyEJRsex+Wg9uQcc8bCAmNBtAYUA5rFZKue9izn0SugFytD0hNp7W1NuuJX3DkzVkwXnkHwnpchMp9W1C67X30uHMJ1LEpAIDKfV9Crg2HMiIebqcdZd+tRtUv3yBr1kootOGi1+ZqqMW+edfCYrEgNDS0w7UyjwJfG/Ooa9R2vmRSV84jQHwmdcrbc4IgoHTHWsReejPCMy+BOs6MpPGPwFFTDsuv21rcL/WWBTBcMBrqmGRo4szoNv5hOCylqC86AgBwNVhRsWs9EkbfCX33C6AxpiPpuodRm/8LavMPnNe1AUDUwGugS+4DZUQcNMZ0GEfcBoelFPZTJX6vq/S71TAMuBqG/o1rNI2dBalCiYpdG5odr0/ph/CsoVBFJ0EZaUTMxROgju0O64n9njFFm99AaPpgJIyaAU18GpSRRoRlDAloQLW1ruSJjyJ60J+hiU+FKrobuv35AQiCgJqc3V7jpHIFFPpIz0+gGyag7bWVfb8WoakXInboDVBFJ8E44jao49NQtvMjz5jIPiMQah4AZaQR6phkJIy+C25bLRpO5gSoKt9jHrW9NoB55C/BmknBkked0jTZq4rhtFZCb+7v2SZT6aBNyGxTmLgbahv3/e3Brys6AsHlhL77AM8YVXTjK6FAhZS/ajuby16Pit0bERIRD8Vvryb8xe10oK74sFdNEqkUenN/1BW0XpMgCKg5tgu28gLokno3bnO7UX14J1SGRBxd8QiyF07Aoddm4tTBloPc1zpaFwC4HTYILmeTALLm7kX2wgk48MIU5H/yPJx1Fp+uvdV1taO22vwDXs8dAAhNHdji763b6UD5T59BptJCHWf23eIDjHnUOuZRYARrJgVTHok+p8lms8Fms3kuV1dXt/tGHdYqAGjSwct1EZ7rWiO43ShY/wq03Xp5DtU5rJWQyBSQq3VeYxW6CDisle1eb1v4q7bTyn74H4o2LYXb3gBllAmpU56GVK7wzeJb4KqzAG43FNqzatJGoKEsv+X9GqzY/8wNcDsdkEilMF1zP0JTBwIAnLWn4LbXo+Tb9xE/4jYYr5qG6iM/4vj7TyD11mehT+nr15qA9tf1e0WbXodCb/B6coemXYjwrGEIiYiDrbIIxZvfwLG35yB92kt+f9vitPbU5rRWQt7M763zrOeO5dAO5H74b7gdNih0kTBPeRpybZhvC2gF80gc5tHv9uvieQQEbyYFUx6Jbprmz5+PuXPntutGKvduRv4nz3kud79pXrvm+b2Cz15EQ2ku0m5/ocNzdUSga4vsMwJ68wA4aypRsn0Vjn/wL6Tf8WKL5yZ0JmmIBhl3LYXLXo+anF0o3LAYIRHx0Kf0AwQ3ACAsYwhihkwEAGjiU1Gb/wvKf/okYCHVESe/eQ9V+7ci7bZnve7/iN5XeP6tju0OdWx3HHh+MqzH93q90jpf6VL6IeOupXDWWVD+82fI/eBJpE9/OaBvYzCPmsc8almw5xHwx8ykQOeR6KZpzpw5mD17tudydXU1TCbTOfY4IyxjCLSJZ85md7scABpfBSn0Bs92p7UK6vjWD6vlf/oiLIe+R9rtzyEk7MyhYIUuEoLLAWe91evVncNa5bdPqwSqttNkKh1kKh1gSIQmMRPZ88fh1MFtiOxzRTOz+YZMEwZIpXDUer8yddZWQaFv+X6VSKVQGhIANAaQrewESr55D/qUfr/NKYMqOslrH1V0N9Tm7W9uOp9rb10AULJtFUq3vYfUKf9p9VCwMtIIuSYMtsrCgAVUe2qT6yLhPOvog9NaBflZzx1ZiBoyQwKUhgRoTVk48PwtqNi1HnGX/tW3RZwD86h5zKPzN4+A4M2kYMoj0ec0KZVKhIaGev2IJVNqoPytKKUhAaroJMh1kajJ2eUZ42qoRW3hQWhNWS3OIwhC45P44Dak3vYMlBHxXtdrjGmQyOSw/m7ehvJ8OCyl55y3IwJVWwt7Nf7nsvugkpZJ5Qpo4tO9TiwU3G7U5OyGJlH8/SoIAoTfQlwqV0Cb0AMNFd6HZm0VBQH7eG976yr59n2c/PodmCcvgCahR6u3Y7eUwVlf7fVHy9/aU5vWlOX1ewsANcd+bvW5IwhuCE5HxxfdBsyj5jGPzt88Or2OYMykYMqjTvmeJolEgpiLx6Pk6/9CZUhESEQcir9cDoU+CmEZQz3jjix/EOFZQxE9eBwAoODTF1GV/SVSbnwSshANHDWN723KVFpIFUrIVDoY+v8JBRsWQ6bWQ6bSouCzl6A1ZfktpAJVm62yCFX7v0Jo6kDINWGwV5ej5Nv3IJWHIDRtcHNL8amYIRORt24hNMZ0aBMzULpjDdz2Bhj6jwIA5K5ZgJDQKBhH3gGg8XteNMZ0KCONEFwOWA7vROXeL2Aae/+ZOS+5AbkfPonypD7Qp/RD9dEfYTm0A2m3LfJ7Pe2tq+Tb91C8ZQWSJz6KkPA4z+MkDVFDplTDZavHya9WIjxrGOS6SNgri1C4aSmUkUbofzt/oqvWFn3ReBx5828o2b4KYekXoSp7K+qKDsN0beMRHZe9HiVf/7fxE0V6A5x1FpTt/B8cNeUI73VZQGvzJeYR8wjoGnnUntrOl0wKljzqtC+3jBk6CW57A058vOi3L1zrDfPk+V7vw9qriuCsPXOGf/mPHwMAji6f7TVXt+seguGC0QCAhNF3AxIJjn8wF4LTAX3qQJiuuR+B5I/apPIQ1OZlo2zHGrgarJBrI6BL7oP0aS8F5FySiN7D4ayzoHjLW42H9uPMME9e4HmbwWEphUQi8Yx32xtQ8OmLsFeXQapQQhVlQvKEOYjoPdwzJjxrKExjZ6Hkm/dQ8PnLUEWZkHLDE55PtARCW+sq//ETCC4Hjn/gfT5N3OW3IP6KKZBIpag/mYPKPZvgarA2npBpHoj4EbdCKg/seR5trU3XrSeSJ/4fir98E8Wb34TSkICUG//lOflXIpGhoTwfle8/AWddNWSaUGgTeiDt9uehjkkOaG2+xjxiHnWFPGpPbedLJgVLHnXal1sS0R9XV/tySyL6Y+vSX25JREREdL5h00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR5J11w2U7P0Lp9lVwWCuhjjUjccy90CZmNDu2/KfPULlnExpKcwEAamM6jFfe3uL4Ex8/h4qfPkXC6LsRM2SCv0poVlvq+r2q7C3I/fAphGUMQfe/PunZfurAtyj/8RPUFR2Gq74GPe56DZr4VH+W0KK21la1/2sUb1kO+6mTUEYmwnjVNISlD/Zcv/uxEc3uZ7xqOmKH3uDz9bekLXXVl+aieMtbqC86DPupkmZ/x8p++BjlP34M+6kSAIAqOglxl0/2qj1QBEHAyS1vofznz+FqsELbrRdMY++HypDY4j7W3H0o2fYB6oqPwFlTgZQb5yI8c6jXmLy1C1G5Z5PXNn3qhUi9ZYFf6vC3YM0jIHgzKVjzCGAmna0rZVKnHGmqyt6Kwg1LEHf5Lehx5xKo48w4tvIROKxVzY635u5FRJ8rkHrbs0if9hJCwqJxbOXDsFeXNRl76sA21BUchEJv8HcZTbS1rtNsVSdRuPE1aJN6N7nObW+AtlsvGK+a5q9li9Lmx+zEL8hd/W8Y+v8JGXe9hrDMS3D8vcdQX3LcM6bXQx96/XQb9xAgkSA8a1igympzXW5HA5QR8TCOvANyXWSzY0JCo2AcOQ097lyMHjNehb77BY21//ZHNpBKt72Psp3rYBo7Cz2mvwxZiArHVv4dboe9xX1c9nqo48wwjbnvnHPrUy/0evyS//J/vl5+QARrHgHBm0nBmkcAM6k5XSmTOqVpKv1uNQwDroah/2ioY5JhGjsLUoUSFbs2NDs+eeKjiB70Z2jiU6GK7oZuf34AgiCgJme31zh7dRkKPn8JSRMfhUQW+INoba0LAAS3C3mr5yF++BQoI+KbXB/ZbyTih98CffcB/lx6q9paW9n3axGaeiFih94AVXQSjCNugzo+DWU7P/KMUegjvX4sv26HLrkflJHGAFXV9rq0CRlIGDUDEb2vgFSuaHZMWMYQhKUPhsqQCFWUCcYrb4c0RI26/AP+LKUJQRBQumMtYi+9GeGZl0AdZ0bS+EfgqCmH5ddtLe4Xlj4YxiunIjxraItjAEAqV3g9fnK13tclBESw5hEQvJkUrHkEMJOa05UyKeBNk9vpQF3xYejN/T3bJFIp9Ob+qCsQ9wC6HTYILqfXHSK43chbswAxl1wPdUyyr5fd+praWdfJr96GXBcOw4CrA7HMdmlPbbX5B5qEamjqQNS28CR1WCthObwThgF/8t3CW+GL38XWCG4XqrK3wG1vgMaU5ZM5xbJXFcNprfSqT6bSQZuQ2eLj0BbW3L3IXjgBB16YgvxPnoezztLhOQMtWPMICN5MCtY8AphJHRWITBL98sdms8Fms3kuV1dXt+sGXXUWwO2GQhvhvRBtBBrK8kXNUbTpdSj0Bq8nQcm29yGRyhB90fh2rauj2lOXNS8bFbvWI+OupYFYYru1pzantRJy3VnjdRFwWiubHV+5exNkSg3CMwN3KNwXv4stqS/JweHX74XbaYcsRI2UG+cG/I/n6cP5imYeh9benmlNaNqFCM8ahpCIONgqi1C8+Q0ce3sO0qe9BIlU1qG5xWAetS5YMylY8whgJnVEoDJJdNM0f/58zJ0712c33F4nv3kPVfu3Iu22ZyFVhAAA6ooOo+z7tci4cwkkEkknr1Acl60OeWsWwHTtbMi1YZ29nE5XsXsDIvqM8Dym5zulwYSMu5bCZavFqV++wYm1C5E6dZFfQ6py72bkf/Kc53L3m+b57bYiel/h+bc6tjvUsd1x4PnJsB7f6/Uq0l+YR77HTDoj2PIIYCb5iuimac6cOZg9e7bncnV1NUwmU5tvUKYJA6RSOGq9u0pnbRUU+uZPYjutZNsqlG57D6lT/gN1nNmz3ZqbDWftKexfdOOZwW43CjcuQdn3a9Bz9rttXmdbtbUuW2UR7KdOIufdf5zZKAgAgN1PjETWfSsC/l56S9rzmMl1kXCe9crBaa1q9kRFa+4+2MrzkXz9P323aBE68rvYGqlcAaUhAQCgMaajtvAQyr5fi27Xzm5lz/YLyxgCbWKm57Lb5QDQ+Oru9yciO61VUMebm+zfEcpII+SaMNgqCwPSNDGPWhesmRSseQQwk3zJX5kkumlSKpVQKpUdvkGpXAFNfDpqcnZ7PjIouN2oydmNqEHjWtyv5Nv3cfKbd5F6ywJoEnp4XRfZ78omd8qxlY8gou9IGPqP7vCaxWhrXaqobsiYucxrW/GXb8Jlq0fi1TOhCI0OxLJFac9jpjVloSZnl9dHX2uO/QxtM++hV+xaD7UxHZo43z5pWtPe38V2EdwQnA7fznkWmVIDmVJz5iYFAXJdJGpydnk+Eu5qqEVt4UFEDRrr09u2W8rgrK8O2KfEmEetC9ZMCtY8AphJvuSvTOqUj3TEDJmIvHULoTGmQ5uYgdIda+C2N8DQfxQAIHfNgt8+InkHAKDk2/dQvGUFkic+ipDwODhqGt+HloaoIVOqIdeEQa7xPpwskcmh0EVCFdX2V5+BqEuqCIE6NsVrf5lKBwBe25111bBbSuGoqQAA2Mob39dW6CI7/MqjLdr6mEVfNB5H3vwbSravQlj6RajK3oq6osMwnfWqxtXQeKg4YfSdAavl99pal9vpQENZXuO/XU44aspRV3wUshC151Vc0RfLEJo2CIqwGLjtdajatwXW3L0wTw7sdxhJJBLEXDweJV//FypDIkIi4lD85XIo9FEIyzjzKZQjyx9EeNZQRA8eBwBw2ephqyz0XG+vOom64qOQq/UICY+Fy1aPk1+tRHjWMMh1kbBXFqFw01IoI43Qpw4MaI2+EKx51NbazqdMCtY8AphJQNfOpE5pmiJ6D4ezzoLiLW81HpaLM8M8eQEUvx0qdVhKvc4FKP/xEwguB45/4H0OQ9zltyD+iikBXfu5tLUuMSyHvsOJdf/xXM798N8AAl97W2vTdeuJ5In/h+Iv30Tx5jehNCQg5cZ/NQnlqv1bIUBARO/hAavl99pal6OmAocWz/BcLt2+CqXbV0GX3BdpUxc1jqmtQt7aBXDUVEKm0kIV2x3myQsQ2gkNRczQSXDbG3Di40W/fZFcb5gnz/c6V8NeVQRn7ZlPmdQVHcLR5Q94LhduWAwAiOx3FZLGPwKJVIr6kzmo3LMJrgZr40nQ5oGIH3ErpPLz7xyQYM0jIHgzKVjzCGAmAV07kySC8Nub1m1UXV2NsLAw9Hn0Y8hUWp8uioiCm6uhFvvmXQuLxYLQ0NAOz8c8IqKOEJtJ/H/PEREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYnApomIiIhIBDZNRERERCKwaSIiIiISgU0TERERkQhsmoiIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEkHeWTdctvMjlG5fBYe1EupYMxLH3AttYkar+1Vlb0Huh08hLGMIuv/1Sc92l60eRV+8Dsuv2+Gsq4YyIg7RF41H1IVj/VlGE4Ig4OSWt1D+8+dwNVih7dYLprH3Q2VIPOd+rd0ftsoiFG5cgtq8/XC7HAhNvRCJY+6BQhfp75I82lNb2Q8fo/zHj2E/VQIAUEUnIe7yyQhLH+w1rvbELyj68k3UFfwKSKVQx5mRestCSBVKv9YEtO13sb40F8Vb3kJ90WHYT5UgYfTdiBkywWvMyW/eheXANjSUn4BUoYTWlAXjVdOhijL5vZaz+fp5lrd2ISr3bPIaq0+9EKm3LPD52gMpWPMICN5MCtY8AoI3k4IhjzrlSFNV9lYUbliCuMtvQY87l0AdZ8axlY/AYa065362qpMo3PgatEm9m1xXuGExqo/+iKQJc5B573JEXzwB+Z+9CMuv3/mrjGaVbnsfZTvXwTR2FnpMfxmyEBWOrfw73A57i/u0dn+47PU4uuJhABKk3vYM0u94AYLLgZz//gOC2x2gytpXW0hoFIwjp6HHnYvRY8ar0He/AMffewz1pbmeMbUnfsHRt+dAbx6I9BmvoMeMVxE9eBwgkfi9prb+LrodDVBGxMM48g7IW/jjYM3dh6jB1yJ9+sswT3kagsuFoysehste789SmvDH8wxoDKVeD33o+Un+y//5Y/kBE8x5BARvJgVjHgHBm0nBkked0jSVfrcahgFXw9B/NNQxyTCNnQWpQomKXRta3Edwu5C3eh7ih0+BMiK+yfW1+b/A0O8q6FP6QRkRh6iB10Ada0Ztwa/+LMV7jYKA0h1rEXvpzQjPvATqODOSxj8CR005LL9ua3G/1u6P2hO/wH6qBEnXPQx1bHeoY7sjafwjqCs6jJrju7t0bWEZQxCWPhgqQyJUUSYYr7wd0hA16vIPeMYUbFiM6IuuQ9ylN0IdkwxVlAkRvS6HVB7i97ra+ruoTchAwqgZiOh9BaRyRbNjUm9ZAMMFjfNp4szoNv5hOCylqC864s9SmvDH8wwApHIFFPpIz49crfdXCQERrHkEBG8mBWseAcGbScGSRwFvmtxOB+qKD0Nv7u/ZJpFKoTf3R13BgRb3O/nV25DrwmEYcHWz12tNPWH5dQfs1WUQBAE1ObthqyhAaOpAn9fQEntVMZzWSq/aZCodtAmZqM1vvjYx94fgtAMSQPK7J4REHgJIJKjN2++nary1p7azCW4XqrK3wG1vgMaUBQBwWKtQV3AQCm04Dr9+L7IXTsCRN/4Ga162X+r4vfb+Lrb5dhpqAQCyADYX/nqeAYA1dy+yF07AgRemIP+T5+Gss/h07YEUzHkEBG8mBWMeAcGbScGUR6LPabLZbLDZbJ7L1dXV7bpBV50FcLuh0EZ4L0QbgYay/Gb3seZlo2LXemTctbTFeRPH3IP8jxfhl2cmAVIZJBIpTH+eDV1yn3atsz1OH2ZU6M6qTRfR4iFIMfeHxpQFqUKNok2vw3jl7RAgoOiLZYDbDYe1wg+VNNWe2k6rL8nB4dfvhdtphyxEjZQb50IdkwygMfwAoHjrCiSMuhPqeDMq93yBo289hIx7lrV63kVHtOd3sa0EtxsF61+BtlsvqGNTfDKnGP56noWmXYjwrGEIiYiDrbIIxZvfwLG35yB92kuQSGU+reFcmEfiBGsmBWMeAcGbScGUR6Kbpvnz52Pu3Ll+WcS5uGx1yFuzAKZrZ0OuDWtxXNn3H6E2/yC6//VJhITHwpqXjYJPX4RCb0CoeYBf1la5dzPyP3nOc7n7TfP8cjsKbThSbngM+Z88j7Kd6wCJBBG9r4A6Pg0SiX8OFvqyNqXBhIy7lsJlq8WpX77BibULkTp1EdQxyRAEAQAQNfAaGPqPBgBo4tNQk7MLlbs2wDjyjo4V0skKPnsRDaW5SLv9hc5eyjmJfZ5F9L7C8+/Tb8sceH4yrMf3er2K9DfmUfOCNZOYR75zPmRSV84j0U3TnDlzMHv2bM/l6upqmExtP/NepgkDpFI4ar1fDThrq6DQNz2JzVZZBPupk8h59x9nNv72i737iZHIum8FFHoDir98AymT5iKsx0UAAHWcGfXFR1G6/UO/hVRYxhBoEzM9l90uB4DGV0EKvcGz3Wmtgjre3OwcYu+P0NSB6Pm3d+CstQBSGeRqHbKfnoiQFt7n7Shf1HaaVK6A0pAAANAY01FbeAhl369Ft2tne2pUxSR57aOKToLdUuqTWlrS1t/Ftsr/9EVYDn2PtNufQ0hYdIfnawt/PM+UkcYm+ykjjZBrwmCrLAxo08Q8al6wZtIfIY+A4M2kYMoj0U2TUqmEUtnxj1tK5Qpo4tNRk7Mb4ZlDATQeLqzJ2Y2oQeOajFdFdUPGzGVe24q/fBMuWz0Sr54JRWg0BKcdgsvZ9NMNUikg+O+THDKlBjKlxnNZEATIdZGoydkFTXwqAMDVUIvawoOIGtT8R43ben+c7rprcnbDWXsKYRlDfFxVI1/U1iLBDcHZGHoh4XFQ6A1oKC/wGmIrL0Bo2oUdK6IVbb3vxRIEAQWfvQTLwW1InbqoxRMY/ckfz7Pm2C1lcNZXe/3hCgTmUfOCNZP+CHkEBG8mBVMedcr3NMUMmYi8dQuhMaZDm5iB0h1r4LY3wNB/FAAgd82C3z4aegekipAm77vKVDoAOLNdroAuuS+KNi2FVKFsPByeuxeVe75Awui7AlaXRCJBzMXjUfL1f6EyJCIkIg7FXy6HQh+FsIyhnnFHlj+I8KyhjR9jRev3BwBU7NoAVXQ3yLXhqM3/BQWfv4LoiycE7Hs22ltb0RfLEJo2CIqwGLjtdajatwXW3L0wT15wZt5LbkDx1hVQx3WHJi4VFXs2oaH8BFImPe73utryuwg0ntDYUJbX+G+XE46actQVH4UsRO159Vrw6Yuoyv4SKTc+CVmIBo6aSgCATKUN2Pe8tLU2Mc8zl60eJ79aifCsYZDrImGvLELhpqVQRhqhD/AJzr4UrHkEBG8mBWseAcGbScGSR53SNEX0Hg5nnQXFW95qPJwaZ4Z58gLPl6I5LKWQtPE7MZL/8g8UbV6GvNXz4KyvQUh4LIwjpgb8y+Rihk6C296AEx8v+u0L13rDPHk+pIozH1e1VxU1HtL+TWv3BwA0lOejaPMyuH6rLe7SmxA9ZGKXr81RW4W8tQvgqKmETKWFKrY7zJMXeH2KKGbIBLiddhSuXwxXfQ3Ucd2ROuXpZg+/+lpbfxcdNRU4tHiG53Lp9lUo3b4KuuS+SJu6CABQ/uPHAICjy2fj97pd9xAMF4z2d0kevn6eSaRS1J/MQeWeTXA1WKHQG6A3D0T8iFsD9nFsfwjmPAKCN5OCMY+A4M2kYMkjiXD6zLc2qq6uRlhYGPo8+jFkKq2v10VEQczVUIt9866FxWJBaGhoh+djHhFRR4jNJP6/54iIiIhEYNNEREREJAKbJiIiIiIR2DQRERERicCmiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhHYNBERERGJwKaJiIiISAQ2TUREREQisGkiIiIiEoFNExEREZEIbJqIiIiIRGDTRERERCQCmyYiIiIiEdg0EREREYkgb++OgiAAAFy2Op8thoj+GE7nRnV1NfR6PSQSSYfmYx4RUUeczo7TWdISidDaiBYUFBTAZDK1Z1ciIg+LxYLQ0NAOzcE8IiJfyM/PR2JiYovXt7tpcrvdKCoq8smrxNZUV1fDZDIhPz+/w+Ha1QRrbcFaFxC8tQWyLkEQUFNTA71ej9DQ0A5nSCDzCODvwPkoWGsL1rqAzskko9EIqbTlM5fa/facVCo9ZzfmD6GhoUH3S3FasNYWrHUBwVtboOoKCwvz2VydkUcAfwfOR8FaW7DWBXStTOKJ4EREREQisGkiIiIiEuG8aJqUSiUef/xxKJXKzl6KzwVrbcFaFxC8tQVrXf4QrPdVsNYFBG9twVoX0DVra/eJ4ERERER/JOfFkSYiIiKizsamiYiIiEgENk1EREREIrBpIiIiIhKBTRMRERGRCGyaiIiIiERg00REREQkApsmIiIiIhH+H5YI6POp9V0XAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 600x1000 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "* Test fine_grained_prune()\n",
            "    target sparsity: 0.00\n",
            "        sparsity before pruning: 0.04\n",
            "        sparsity after pruning: 0.04\n",
            "        sparsity of pruning mask: 0.00\n",
            "* Test failed.\n"
          ]
        }
      ],
      "source": [
        "##################### YOUR CODE STARTS HERE #####################\n",
        "target_sparsity = 0 # please modify the value of target_sparsity\n",
        "##################### YOUR CODE ENDS HERE #####################\n",
        "test_fine_grained_prune(target_sparsity=target_sparsity, target_nonzeros=10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rse5ur_eDj9C"
      },
      "source": [
        "We now wrap the fine-grained pruning function into a class for pruning the whole model. In class `FineGrainedPruner`, we have to keep a record of the pruning masks so that we could apply the masks whenever the model weights change to make sure the model keep sparse all the time."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "TR0JgPAdpLlW"
      },
      "outputs": [],
      "source": [
        "class FineGrainedPruner:\n",
        "    def __init__(self, model, sparsity_dict):\n",
        "        self.masks = FineGrainedPruner.prune(model, sparsity_dict)\n",
        "\n",
        "    @torch.no_grad()\n",
        "    def apply(self, model):\n",
        "        for name, param in model.named_parameters():\n",
        "            if name in self.masks:\n",
        "                param *= self.masks[name]\n",
        "\n",
        "    @staticmethod\n",
        "    @torch.no_grad()\n",
        "    def prune(model, sparsity_dict):\n",
        "        masks = dict()\n",
        "        for name, param in model.named_parameters():\n",
        "            if param.dim() > 1: # we only prune conv and fc weights\n",
        "                masks[name] = fine_grained_prune(param, sparsity_dict[name])\n",
        "        return masks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1pH3xlQFs3nE"
      },
      "source": [
        "## Sensitivity Scan\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O7L8Lm4_bCSY"
      },
      "source": [
        "Different layers contribute differently to the model performance. It is challenging to decide the proper sparsity for each layer. A widely used approach is sensitivity scan.\n",
        "\n",
        "During the sensitivity scan, at each time, we will only prune one layer to see the accuracy degradation. By scanning different sparsities, we could draw the sensitivity curve (i.e., accuracy vs. sparsity) of the corresponding layer.\n",
        "\n",
        "Here is an example figure for sensitivity curves. The x-axis is the sparsity or the percentage of #parameters dropped (*i.e.*, sparsity). The y-axis is the validation accuracy. (This is Figure 6 in [Learning both Weights and Connections for Efficient\n",
        "Neural Networks](https://arxiv.org/pdf/1506.02626.pdf))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSQ1jR8YE8-d"
      },
      "source": [
        "![sensitivity curves.png]()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6f3YWd7eDpY7"
      },
      "source": [
        "The following code cell defines the sensitivity scan function that returns the sparsities scanned, and a list of accuracies for each weight to be pruned."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "IhkFEhHDs6r0"
      },
      "outputs": [],
      "source": [
        "@torch.no_grad()\n",
        "def sensitivity_scan(model, dataloader, scan_step=0.1, scan_start=0.4, scan_end=1.0, verbose=True):\n",
        "    sparsities = np.arange(start=scan_start, stop=scan_end, step=scan_step)\n",
        "    accuracies = []\n",
        "    named_conv_weights = [(name, param) for (name, param) \\\n",
        "                          in model.named_parameters() if param.dim() > 1]\n",
        "    for i_layer, (name, param) in enumerate(named_conv_weights):\n",
        "        param_clone = param.detach().clone()\n",
        "        accuracy = []\n",
        "        for sparsity in tqdm(sparsities, desc=f'scanning {i_layer}/{len(named_conv_weights)} weight - {name}'):\n",
        "            fine_grained_prune(param.detach(), sparsity=sparsity)\n",
        "            acc = evaluate(model, dataloader, verbose=False)\n",
        "            if verbose:\n",
        "                print(f'\\r    sparsity={sparsity:.2f}: accuracy={acc:.2f}%', end='')\n",
        "            # restore\n",
        "            param.copy_(param_clone)\n",
        "            accuracy.append(acc)\n",
        "        if verbose:\n",
        "            print(f'\\r    sparsity=[{\",\".join([\"{:.2f}\".format(x) for x in sparsities])}]: accuracy=[{\", \".join([\"{:.2f}%\".format(x) for x in accuracy])}]', end='')\n",
        "        accuracies.append(accuracy)\n",
        "    return sparsities, accuracies"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pB_YNZ2iDXyj"
      },
      "source": [
        "Please run the following cells to plot the sensitivity curves. It should take around 2 minutes to finish."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "tQN88zrsIRjE"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 0/9 weight - backbone.conv0.weight:  17%|█▋        | 1/6 [00:01<00:07,  1.60s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.42%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 0/9 weight - backbone.conv0.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.43s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=91.19%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 0/9 weight - backbone.conv0.weight:  50%|█████     | 3/6 [00:04<00:04,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=87.55%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 0/9 weight - backbone.conv0.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=83.39%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 0/9 weight - backbone.conv0.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=69.42%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 0/9 weight - backbone.conv0.weight: 100%|██████████| 6/6 [00:08<00:00,  1.37s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.42%, 91.19%, 87.55%, 83.39%, 69.42%, 31.82%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 1/9 weight - backbone.conv1.weight:  17%|█▋        | 1/6 [00:01<00:07,  1.40s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.93%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 1/9 weight - backbone.conv1.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.38s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.88%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 1/9 weight - backbone.conv1.weight:  50%|█████     | 3/6 [00:04<00:04,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.71%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 1/9 weight - backbone.conv1.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=92.40%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 1/9 weight - backbone.conv1.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=91.32%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 1/9 weight - backbone.conv1.weight: 100%|██████████| 6/6 [00:08<00:00,  1.35s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.93%, 92.88%, 92.71%, 92.40%, 91.32%, 84.78%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 2/9 weight - backbone.conv2.weight:  17%|█▋        | 1/6 [00:01<00:06,  1.31s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.94%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 2/9 weight - backbone.conv2.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.32s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.64%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 2/9 weight - backbone.conv2.weight:  50%|█████     | 3/6 [00:04<00:04,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.46%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 2/9 weight - backbone.conv2.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=91.77%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 2/9 weight - backbone.conv2.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=89.85%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 2/9 weight - backbone.conv2.weight: 100%|██████████| 6/6 [00:08<00:00,  1.35s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.94%, 92.64%, 92.46%, 91.77%, 89.85%, 78.56%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 3/9 weight - backbone.conv3.weight:  17%|█▋        | 1/6 [00:01<00:06,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.86%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 3/9 weight - backbone.conv3.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.72%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 3/9 weight - backbone.conv3.weight:  50%|█████     | 3/6 [00:04<00:04,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.23%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 3/9 weight - backbone.conv3.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=91.09%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 3/9 weight - backbone.conv3.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=85.35%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 3/9 weight - backbone.conv3.weight: 100%|██████████| 6/6 [00:08<00:00,  1.35s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.86%, 92.72%, 92.23%, 91.09%, 85.35%, 51.29%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 4/9 weight - backbone.conv4.weight:  17%|█▋        | 1/6 [00:01<00:06,  1.37s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.88%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 4/9 weight - backbone.conv4.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.68%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 4/9 weight - backbone.conv4.weight:  50%|█████     | 3/6 [00:04<00:04,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.22%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 4/9 weight - backbone.conv4.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=89.47%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 4/9 weight - backbone.conv4.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=76.86%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 4/9 weight - backbone.conv4.weight: 100%|██████████| 6/6 [00:08<00:00,  1.34s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.88%, 92.68%, 92.22%, 89.47%, 76.86%, 38.78%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 5/9 weight - backbone.conv5.weight:  17%|█▋        | 1/6 [00:01<00:06,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.92%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 5/9 weight - backbone.conv5.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.71%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 5/9 weight - backbone.conv5.weight:  50%|█████     | 3/6 [00:04<00:04,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.64%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 5/9 weight - backbone.conv5.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=91.88%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 5/9 weight - backbone.conv5.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=89.90%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 5/9 weight - backbone.conv5.weight: 100%|██████████| 6/6 [00:08<00:00,  1.36s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.92%, 92.71%, 92.64%, 91.88%, 89.90%, 82.21%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 6/9 weight - backbone.conv6.weight:  17%|█▋        | 1/6 [00:01<00:06,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.95%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 6/9 weight - backbone.conv6.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.32s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.86%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 6/9 weight - backbone.conv6.weight:  50%|█████     | 3/6 [00:03<00:03,  1.32s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.65%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 6/9 weight - backbone.conv6.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.32s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=92.10%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 6/9 weight - backbone.conv6.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.32s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=90.58%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 6/9 weight - backbone.conv6.weight: 100%|██████████| 6/6 [00:07<00:00,  1.32s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.95%, 92.86%, 92.65%, 92.10%, 90.58%, 83.64%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 7/9 weight - backbone.conv7.weight:  17%|█▋        | 1/6 [00:01<00:05,  1.18s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.93%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 7/9 weight - backbone.conv7.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.28s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.90%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 7/9 weight - backbone.conv7.weight:  50%|█████     | 3/6 [00:03<00:04,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.89%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 7/9 weight - backbone.conv7.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=92.81%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 7/9 weight - backbone.conv7.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.33s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=92.63%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 7/9 weight - backbone.conv7.weight: 100%|██████████| 6/6 [00:08<00:00,  1.33s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.93%, 92.90%, 92.89%, 92.81%, 92.63%, 91.34%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 8/9 weight - classifier.weight:  17%|█▋        | 1/6 [00:01<00:06,  1.37s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.40: accuracy=92.91%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 8/9 weight - classifier.weight:  33%|███▎      | 2/6 [00:02<00:05,  1.36s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.50: accuracy=92.83%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 8/9 weight - classifier.weight:  50%|█████     | 3/6 [00:04<00:04,  1.35s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.60: accuracy=92.82%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 8/9 weight - classifier.weight:  67%|██████▋   | 4/6 [00:05<00:02,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.70: accuracy=92.97%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 8/9 weight - classifier.weight:  83%|████████▎ | 5/6 [00:06<00:01,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=0.80: accuracy=92.67%"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "scanning 8/9 weight - classifier.weight: 100%|██████████| 6/6 [00:08<00:00,  1.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    sparsity=[0.40,0.50,0.60,0.70,0.80,0.90]: accuracy=[92.91%, 92.83%, 92.82%, 92.97%, 92.67%, 92.52%]"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "sparsities, accuracies = sensitivity_scan(\n",
        "    model, dataloader['test'], scan_step=0.1, scan_start=0.4, scan_end=1.0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "ktK3IyAHICVC"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x800 with 9 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def plot_sensitivity_scan(sparsities, accuracies, dense_model_accuracy):\n",
        "    lower_bound_accuracy = 100 - (100 - dense_model_accuracy) * 1.5\n",
        "    fig, axes = plt.subplots(3, int(math.ceil(len(accuracies) / 3)),figsize=(15,8))\n",
        "    axes = axes.ravel()\n",
        "    plot_index = 0\n",
        "    for name, param in model.named_parameters():\n",
        "        if param.dim() > 1:\n",
        "            ax = axes[plot_index]\n",
        "            curve = ax.plot(sparsities, accuracies[plot_index])\n",
        "            line = ax.plot(sparsities, [lower_bound_accuracy] * len(sparsities))\n",
        "            ax.set_xticks(np.arange(start=0.4, stop=1.0, step=0.1))\n",
        "            ax.set_ylim(80, 95)\n",
        "            ax.set_title(name)\n",
        "            ax.set_xlabel('sparsity')\n",
        "            ax.set_ylabel('top-1 accuracy')\n",
        "            ax.legend([\n",
        "                'accuracy after pruning',\n",
        "                f'{lower_bound_accuracy / dense_model_accuracy * 100:.0f}% of dense model accuracy'\n",
        "            ])\n",
        "            ax.grid(axis='x')\n",
        "            plot_index += 1\n",
        "    fig.suptitle('Sensitivity Curves: Validation Accuracy vs. Pruning Sparsity')\n",
        "    fig.tight_layout()\n",
        "    fig.subplots_adjust(top=0.925)\n",
        "    plt.show()\n",
        "\n",
        "plot_sensitivity_scan(sparsities, accuracies, dense_model_accuracy)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9FXNTS9m2ZQC"
      },
      "source": [
        "### Question 4 (15 pts)\n",
        "\n",
        "Please answer the following questions using the information in the above sensitivity curves."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Up-1jYGvFDfo"
      },
      "source": [
        "#### Question 4.1 (5 pts)\n",
        "\n",
        "What's the relationship between pruning sparsity and model accuracy? (*i.e.*, does accuracy increase or decrease when sparsity becomes higher?)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O2kP-8e2FDsE"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ijzmUoL1FDzl"
      },
      "source": [
        "#### Question 4.2 (5 pts)\n",
        "\n",
        "Do all the layers have the same sensitivity?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6qGJ3Cra2819"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5V972fVFfPd"
      },
      "source": [
        "#### Question 4.3 (5 pts)\n",
        "\n",
        "Which layer is the most sensitive to the pruning sparsity?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vl0KTLioFfRo"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w6uBecMG14pq"
      },
      "source": [
        "## \\#Parameters of each layer\n",
        "In addition to accuracy, the number of each layer's parameters also affects the decision on sparsity selection. Layers with more #parameters require larger sparsities.\n",
        "\n",
        "Please run the following code cell to plot the distribution of #parameters in the whole model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "P9eNjKSUGiCk"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def plot_num_parameters_distribution(model):\n",
        "    num_parameters = dict()\n",
        "    for name, param in model.named_parameters():\n",
        "        if param.dim() > 1:\n",
        "            num_parameters[name] = param.numel()\n",
        "    fig = plt.figure(figsize=(8, 6))\n",
        "    plt.grid(axis='y')\n",
        "    plt.bar(list(num_parameters.keys()), list(num_parameters.values()))\n",
        "    plt.title('#Parameter Distribution')\n",
        "    plt.ylabel('Number of Parameters')\n",
        "    plt.xticks(rotation=60)\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "plot_num_parameters_distribution(model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hR7C4hJBMqmb"
      },
      "source": [
        "## Select Sparsity Based on Sensitivity Curves and \\#Parameters Distribution\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9f-qooLCo1pO"
      },
      "source": [
        "### Question 5 (10 pts)\n",
        "\n",
        "Based on the sensitivity curves and the distribution of #parameters in the model, please select the sparsity for each layer.\n",
        "\n",
        "Note that the overall compression ratio of pruned model mostly depends on the layers with larger #parameters, and different layers have different sensitivity to pruning (see Question 4).\n",
        "\n",
        "Please make sure that after pruning, the sparse model is 25% of the size of the dense model, and validation accuracy is higher than 92.5 after finetuning.\n",
        "\n",
        "**Hint**:\n",
        "*   The layer with more #parameters should have larger sparsity. (see *Figure #Parameter Distribution*)\n",
        "*   The layer that is sensitive to the pruning sparsity (i.e., the accuracy will drop quickly as sparsity becomes higher) should have smaller sparsity. (see *Figure Sensitivity Curves*)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "3D2T8n3EHwIz"
      },
      "outputs": [],
      "source": [
        "recover_model()\n",
        "\n",
        "sparsity_dict = {\n",
        "##################### YOUR CODE STARTS HERE #####################\n",
        "    # please modify the sparsity value of each layer\n",
        "    # please DO NOT modify the key of sparsity_dict\n",
        "    'backbone.conv0.weight': 0,\n",
        "    'backbone.conv1.weight': 0,\n",
        "    'backbone.conv2.weight': 0,\n",
        "    'backbone.conv3.weight': 0,\n",
        "    'backbone.conv4.weight': 0,\n",
        "    'backbone.conv5.weight': 0,\n",
        "    'backbone.conv6.weight': 0,\n",
        "    'backbone.conv7.weight': 0,\n",
        "    'classifier.weight': 0\n",
        "##################### YOUR CODE ENDS HERE #######################\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aoJYtUuMTMwO"
      },
      "source": [
        "Please run the following cell to prune the model according to your defined `sparsity_dict`, and print the information of sparse model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "LVRqhiUno65x"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "After pruning with sparsity dictionary\n",
            "  backbone.conv0.weight: 0.00\n",
            "  backbone.conv1.weight: 0.00\n",
            "  backbone.conv2.weight: 0.00\n",
            "  backbone.conv3.weight: 0.00\n",
            "  backbone.conv4.weight: 0.00\n",
            "  backbone.conv5.weight: 0.00\n",
            "  backbone.conv6.weight: 0.00\n",
            "  backbone.conv7.weight: 0.00\n",
            "  classifier.weight: 0.00\n",
            "The sparsity of each layer becomes\n",
            "  backbone.conv0.weight: 0.00\n",
            "  backbone.conv1.weight: 0.00\n",
            "  backbone.conv2.weight: 0.00\n",
            "  backbone.conv3.weight: 0.00\n",
            "  backbone.conv4.weight: 0.00\n",
            "  backbone.conv5.weight: 0.00\n",
            "  backbone.conv6.weight: 0.00\n",
            "  backbone.conv7.weight: 0.00\n",
            "  classifier.weight: 0.00\n",
            "Sparse model has size=35.20 MiB = 100.00% of dense model size\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                     \r"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Sparse model has accuracy=92.95% before fintuning\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x600 with 9 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "pruner = FineGrainedPruner(model, sparsity_dict)\n",
        "print(f'After pruning with sparsity dictionary')\n",
        "for name, sparsity in sparsity_dict.items():\n",
        "    print(f'  {name}: {sparsity:.2f}')\n",
        "print(f'The sparsity of each layer becomes')\n",
        "for name, param in model.named_parameters():\n",
        "    if name in sparsity_dict:\n",
        "        print(f'  {name}: {get_sparsity(param):.2f}')\n",
        "\n",
        "sparse_model_size = get_model_size(model, count_nonzero_only=True)\n",
        "print(f\"Sparse model has size={sparse_model_size / MiB:.2f} MiB = {sparse_model_size / dense_model_size * 100:.2f}% of dense model size\")\n",
        "sparse_model_accuracy = evaluate(model, dataloader['test'])\n",
        "print(f\"Sparse model has accuracy={sparse_model_accuracy:.2f}% before fintuning\")\n",
        "\n",
        "plot_weight_distribution(model, count_nonzero_only=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RO_VGbmXoVjr"
      },
      "source": [
        "## Finetune the fine-grained pruned model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hBr3e-8RogD"
      },
      "source": [
        "As we can see from the outputs of previous cell, even though fine-grained pruning reduces the most of model weights, the accuracy of model also dropped. Therefore, we have to finetune the sparse model to recover the accuracy.\n",
        "\n",
        "Please run the following cell to finetune the sparse model. It should take around 3 minutes to finish."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "DJqfHuE6utbf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Finetuning Fine-grained Pruned Sparse Model\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                      \r"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    Epoch 1 Accuracy 92.96% / Best Accuracy: 92.96%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                      \r"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    Epoch 2 Accuracy 92.96% / Best Accuracy: 92.96%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                      \r"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    Epoch 3 Accuracy 92.92% / Best Accuracy: 92.96%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                      \r"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    Epoch 4 Accuracy 92.95% / Best Accuracy: 92.96%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                      "
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "    Epoch 5 Accuracy 92.84% / Best Accuracy: 92.96%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r"
          ]
        }
      ],
      "source": [
        "num_finetune_epochs = 5\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)\n",
        "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, num_finetune_epochs)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "best_sparse_model_checkpoint = dict()\n",
        "best_accuracy = 0\n",
        "print(f'Finetuning Fine-grained Pruned Sparse Model')\n",
        "for epoch in range(num_finetune_epochs):\n",
        "    # At the end of each train iteration, we have to apply the pruning mask\n",
        "    #    to keep the model sparse during the training\n",
        "    train(model, dataloader['train'], criterion, optimizer, scheduler,\n",
        "        callbacks=[lambda: pruner.apply(model)])\n",
        "    accuracy = evaluate(model, dataloader['test'])\n",
        "    is_best = accuracy > best_accuracy\n",
        "    if is_best:\n",
        "        best_sparse_model_checkpoint['state_dict'] = copy.deepcopy(model.state_dict())\n",
        "        best_accuracy = accuracy\n",
        "    print(f'    Epoch {epoch+1} Accuracy {accuracy:.2f}% / Best Accuracy: {best_accuracy:.2f}%')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J9mP8tbNTmzD"
      },
      "source": [
        "Run the following cell to see the information of best finetuned sparse model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "-mkDWmfyQ63G"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Sparse model has size=35.20 MiB = 100.00% of dense model size\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                     "
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Sparse model has accuracy=92.96% after fintuning\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r"
          ]
        }
      ],
      "source": [
        "# load the best sparse model checkpoint to evaluate the final performance\n",
        "model.load_state_dict(best_sparse_model_checkpoint['state_dict'])\n",
        "sparse_model_size = get_model_size(model, count_nonzero_only=True)\n",
        "print(f\"Sparse model has size={sparse_model_size / MiB:.2f} MiB = {sparse_model_size / dense_model_size * 100:.2f}% of dense model size\")\n",
        "sparse_model_accuracy = evaluate(model, dataloader['test'])\n",
        "print(f\"Sparse model has accuracy={sparse_model_accuracy:.2f}% after fintuning\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yAygqoc_eEax"
      },
      "source": [
        "# Channel Pruning\n",
        "\n",
        "In this section, we will implement the channel pruning. Channel pruning removes an entire channel, so that it can achieve inference speed up on existing hardware like GPUs. Similarly, we remove the channels whose weights are of smaller magnitudes (measured by Frobenius norm)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "sPZDhDWlQc6-"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "                                                     "
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "dense model has accuracy=92.95%\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r"
          ]
        }
      ],
      "source": [
        "# firstly, let's restore the model weights to the original dense version\n",
        "#   and check the validation accuracy\n",
        "recover_model()\n",
        "dense_model_accuracy = evaluate(model, dataloader['test'])\n",
        "print(f\"dense model has accuracy={dense_model_accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q9zH6n8asAy_"
      },
      "source": [
        "## Remove Channel Weights\n",
        "\n",
        "Unlike fine-grained pruning, we can remove the weights entirely from the tensor in channel pruning. That is to say, the number of output channels is reduced:\n",
        "\n",
        "> $\\#\\mathrm{out\\_channels}_{\\mathrm{new}} = \\#\\mathrm{out\\_channels}_{\\mathrm{origin}} \\cdot (1 - \\mathrm{sparsity})$\n",
        "\n",
        "The weight tensor $W$ is still dense after channel pruning. Thus, we will refer to *sparsity* as ***prune ratio***.\n",
        "\n",
        "Like fine-grained pruning, we can use different pruning rates for different layers. However, we use a uniform pruning rate for all the layers for now. We are targeting 2x computation reduction, which is roughly 30% uniform pruning rate (think about why).\n",
        "\n",
        "Feel free to try out different pruning ratios per layer at the end of this section. You can pass in a list of ratios to the `channel_prune` function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KIGCVkQKHyDH"
      },
      "source": [
        "### Question 6 (10 pts)\n",
        "\n",
        "Please complete the following functions for channel pruning.\n",
        "\n",
        "Here we naively prune all output channels other than the first $\\#\\mathrm{out\\_channels}_{\\mathrm{new}}$ channels."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "aFPMZzWlyvUR"
      },
      "outputs": [],
      "source": [
        "def get_num_channels_to_keep(channels: int, prune_ratio: float) -> int:\n",
        "    \"\"\"A function to calculate the number of layers to PRESERVE after pruning\n",
        "    Note that preserve_rate = 1. - prune_ratio\n",
        "    \"\"\"\n",
        "    ##################### YOUR CODE STARTS HERE #####################\n",
        "    return int(round(0))\n",
        "    ##################### YOUR CODE ENDS HERE #####################\n",
        "\n",
        "@torch.no_grad()\n",
        "def channel_prune(model: nn.Module,\n",
        "                  prune_ratio: Union[List, float]) -> nn.Module:\n",
        "    \"\"\"Apply channel pruning to each of the conv layer in the backbone\n",
        "    Note that for prune_ratio, we can either provide a floating-point number,\n",
        "    indicating that we use a uniform pruning rate for all layers, or a list of\n",
        "    numbers to indicate per-layer pruning rate.\n",
        "    \"\"\"\n",
        "    # sanity check of provided prune_ratio\n",
        "    assert isinstance(prune_ratio, (float, list))\n",
        "    n_conv = len([m for m in model.backbone if isinstance(m, nn.Conv2d)])\n",
        "    # note that for the ratios, it affects the previous conv output and next\n",
        "    # conv input, i.e., conv0 - ratio0 - conv1 - ratio1-...\n",
        "    if isinstance(prune_ratio, list):\n",
        "        assert len(prune_ratio) == n_conv - 1\n",
        "    else:  # convert float to list\n",
        "        prune_ratio = [prune_ratio] * (n_conv - 1)\n",
        "\n",
        "    # we prune the convs in the backbone with a uniform ratio\n",
        "    model = copy.deepcopy(model)  # prevent overwrite\n",
        "    # we only apply pruning to the backbone features\n",
        "    all_convs = [m for m in model.backbone if isinstance(m, nn.Conv2d)]\n",
        "    all_bns = [m for m in model.backbone if isinstance(m, nn.BatchNorm2d)]\n",
        "    # apply pruning. we naively keep the first k channels\n",
        "    assert len(all_convs) == len(all_bns)\n",
        "    for i_ratio, p_ratio in enumerate(prune_ratio):\n",
        "        prev_conv = all_convs[i_ratio]\n",
        "        prev_bn = all_bns[i_ratio]\n",
        "        next_conv = all_convs[i_ratio + 1]\n",
        "        original_channels = prev_conv.out_channels  # same as next_conv.in_channels\n",
        "        n_keep = get_num_channels_to_keep(original_channels, p_ratio)\n",
        "\n",
        "        # prune the output of the previous conv and bn\n",
        "        prev_conv.weight.set_(prev_conv.weight.detach()[:n_keep])\n",
        "        prev_bn.weight.set_(prev_bn.weight.detach()[:n_keep])\n",
        "        prev_bn.bias.set_(prev_bn.bias.detach()[:n_keep])\n",
        "        prev_bn.running_mean.set_(prev_bn.running_mean.detach()[:n_keep])\n",
        "        prev_bn.running_var.set_(prev_bn.running_var.detach()[:n_keep])\n",
        "\n",
        "        # prune the input of the next conv (hint: just one line of code)\n",
        "        ##################### YOUR CODE STARTS HERE #####################\n",
        "        next_conv.weight.set_(0)\n",
        "        ##################### YOUR CODE ENDS HERE #####################\n",
        "\n",
        "    return model\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0IIVDYLe5Asd"
      },
      "source": [
        "Run the following cell to perform a sanity check to make sure the implementation is correct."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "9o0cU3B34_w1"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "set_() received an invalid combination of arguments - got (int), but expected one of:\n * ()\n      didn't match because some of the arguments have invalid types: (!int!)\n * (torch.Storage source)\n      didn't match because some of the arguments have invalid types: (!int!)\n * (torch.Storage source, int storage_offset, tuple of ints size, tuple of ints stride = None)\n * (Tensor source)\n      didn't match because some of the arguments have invalid types: (!int!)\n * (Tensor source, int storage_offset, tuple of ints size, tuple of ints stride = None)\n",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[30], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m dummy_input \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrandn(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m32\u001b[39m, \u001b[38;5;241m32\u001b[39m)\u001b[38;5;241m.\u001b[39mcuda()\n\u001b[0;32m----> 2\u001b[0m pruned_model \u001b[38;5;241m=\u001b[39m \u001b[43mchannel_prune\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprune_ratio\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.3\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m pruned_macs \u001b[38;5;241m=\u001b[39m get_model_macs(pruned_model, dummy_input)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m pruned_macs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m305388064\u001b[39m\n",
            "File \u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/utils/_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
            "Cell \u001b[0;32mIn[29], line 50\u001b[0m, in \u001b[0;36mchannel_prune\u001b[0;34m(model, prune_ratio)\u001b[0m\n\u001b[1;32m     46\u001b[0m     prev_bn\u001b[38;5;241m.\u001b[39mrunning_var\u001b[38;5;241m.\u001b[39mset_(prev_bn\u001b[38;5;241m.\u001b[39mrunning_var\u001b[38;5;241m.\u001b[39mdetach()[:n_keep])\n\u001b[1;32m     48\u001b[0m     \u001b[38;5;66;03m# prune the input of the next conv (hint: just one line of code)\u001b[39;00m\n\u001b[1;32m     49\u001b[0m     \u001b[38;5;66;03m##################### YOUR CODE STARTS HERE #####################\u001b[39;00m\n\u001b[0;32m---> 50\u001b[0m     \u001b[43mnext_conv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     51\u001b[0m     \u001b[38;5;66;03m##################### YOUR CODE ENDS HERE #####################\u001b[39;00m\n\u001b[1;32m     53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m model\n",
            "\u001b[0;31mTypeError\u001b[0m: set_() received an invalid combination of arguments - got (int), but expected one of:\n * ()\n      didn't match because some of the arguments have invalid types: (!int!)\n * (torch.Storage source)\n      didn't match because some of the arguments have invalid types: (!int!)\n * (torch.Storage source, int storage_offset, tuple of ints size, tuple of ints stride = None)\n * (Tensor source)\n      didn't match because some of the arguments have invalid types: (!int!)\n * (Tensor source, int storage_offset, tuple of ints size, tuple of ints stride = None)\n"
          ]
        }
      ],
      "source": [
        "dummy_input = torch.randn(1, 3, 32, 32).cuda()\n",
        "pruned_model = channel_prune(model, prune_ratio=0.3)\n",
        "pruned_macs = get_model_macs(pruned_model, dummy_input)\n",
        "assert pruned_macs == 305388064\n",
        "print('* Check passed. Right MACs for the pruned model.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6aKXW5BO6Hrf"
      },
      "source": [
        "Now let's evaluate the performance of the model after uniform channel pruning with 30% pruning rate.\n",
        "\n",
        "As you may see, directly removing 30% of the channels leads to low accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MyZkwnGW6aP0"
      },
      "outputs": [],
      "source": [
        "pruned_model_accuracy = evaluate(pruned_model, dataloader['test'])\n",
        "print(f\"pruned model has accuracy={pruned_model_accuracy:.2f}%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SoqUbcUN6yS_"
      },
      "source": [
        "## Ranking Channels by Importance\n",
        "\n",
        "As you can see, removing the first 30% of channels in all layers leads to significant accuracy reduction. One potential method to remedy the issue is to find the **less important** channel weights to remove. A popular criterion for importance is to use the Frobenius norm of the weights corresponding to each input channel:\n",
        "\n",
        "> $importance_{i} = \\|W_{i}\\|_2, \\;\\; i = 0, 1, 2,\\cdots, \\#\\mathrm{in\\_channels}-1$\n",
        "\n",
        "We can sort the channel weights from more important to less important, and then keep the frst $k$ channels for each layer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AUOLUBjbNLbq"
      },
      "source": [
        "### Question 7 (15 pts)\n",
        "Please complete the following functions for sorting the weight tensor based on the Frobenius norm.\n",
        "\n",
        "**Hint**:\n",
        "* To calculate Frobenius norm of a tensor, Pytorch provides [`torch.norm`](https://pytorch.org/docs/master/generated/torch.norm.html?highlight=torch+norm#torch.norm) APIs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8fpUuOmmsJQZ"
      },
      "outputs": [],
      "source": [
        "# function to sort the channels from important to non-important\n",
        "def get_input_channel_importance(weight):\n",
        "    in_channels = weight.shape[1]\n",
        "    importances = []\n",
        "    # compute the importance for each input channel\n",
        "    for i_c in range(weight.shape[1]):\n",
        "        channel_weight = weight.detach()[:, i_c]\n",
        "        ##################### YOUR CODE STARTS HERE #####################\n",
        "        importance = 0\n",
        "        ##################### YOUR CODE ENDS HERE #####################\n",
        "        importances.append(importance.view(1))\n",
        "    return torch.cat(importances)\n",
        "\n",
        "@torch.no_grad()\n",
        "def apply_channel_sorting(model):\n",
        "    model = copy.deepcopy(model)  # do not modify the original model\n",
        "    # fetch all the conv and bn layers from the backbone\n",
        "    all_convs = [m for m in model.backbone if isinstance(m, nn.Conv2d)]\n",
        "    all_bns = [m for m in model.backbone if isinstance(m, nn.BatchNorm2d)]\n",
        "    # iterate through conv layers\n",
        "    for i_conv in range(len(all_convs) - 1):\n",
        "        # each channel sorting index, we need to apply it to:\n",
        "        # - the output dimension of the previous conv\n",
        "        # - the previous BN layer\n",
        "        # - the input dimension of the next conv (we compute importance here)\n",
        "        prev_conv = all_convs[i_conv]\n",
        "        prev_bn = all_bns[i_conv]\n",
        "        next_conv = all_convs[i_conv + 1]\n",
        "        # note that we always compute the importance according to input channels\n",
        "        importance = get_input_channel_importance(next_conv.weight)\n",
        "        # sorting from large to small\n",
        "        sort_idx = torch.argsort(importance, descending=True)\n",
        "\n",
        "        # apply to previous conv and its following bn\n",
        "        prev_conv.weight.copy_(torch.index_select(\n",
        "            prev_conv.weight.detach(), 0, sort_idx))\n",
        "        for tensor_name in ['weight', 'bias', 'running_mean', 'running_var']:\n",
        "            tensor_to_apply = getattr(prev_bn, tensor_name)\n",
        "            tensor_to_apply.copy_(\n",
        "                torch.index_select(tensor_to_apply.detach(), 0, sort_idx)\n",
        "            )\n",
        "\n",
        "        # apply to the next conv input (hint: one line of code)\n",
        "        ##################### YOUR CODE STARTS HERE #####################\n",
        "        next_conv.weight.copy_(0)\n",
        "        ##################### YOUR CODE ENDS HERE #####################\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-fo60_ni-T21"
      },
      "source": [
        "Now run the following cell to sanity check if the results are correct."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D_oR3Qxd-TOj"
      },
      "outputs": [],
      "source": [
        "print('Before sorting...')\n",
        "dense_model_accuracy = evaluate(model, dataloader['test'])\n",
        "print(f\"dense model has accuracy={dense_model_accuracy:.2f}%\")\n",
        "\n",
        "print('After sorting...')\n",
        "sorted_model = apply_channel_sorting(model)\n",
        "sorted_model_accuracy = evaluate(sorted_model, dataloader['test'])\n",
        "print(f\"sorted model has accuracy={sorted_model_accuracy:.2f}%\")\n",
        "\n",
        "# make sure accuracy does not change after sorting, since it is\n",
        "# equivalent transform\n",
        "assert abs(sorted_model_accuracy - dense_model_accuracy) < 0.1\n",
        "print('* Check passed.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aLdnjTU4-m4O"
      },
      "source": [
        "Finally, we compare the pruned models' accuracy with and without sorting."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aVLm3dsh5cnC"
      },
      "outputs": [],
      "source": [
        "channel_pruning_ratio = 0.3  # pruned-out ratio\n",
        "\n",
        "print(\" * Without sorting...\")\n",
        "pruned_model = channel_prune(model, channel_pruning_ratio)\n",
        "pruned_model_accuracy = evaluate(pruned_model, dataloader['test'])\n",
        "print(f\"pruned model has accuracy={pruned_model_accuracy:.2f}%\")\n",
        "\n",
        "\n",
        "print(\" * With sorting...\")\n",
        "sorted_model = apply_channel_sorting(model)\n",
        "pruned_model = channel_prune(sorted_model, channel_pruning_ratio)\n",
        "pruned_model_accuracy = evaluate(pruned_model, dataloader['test'])\n",
        "print(f\"pruned model has accuracy={pruned_model_accuracy:.2f}%\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_5HsoOcAOAJ"
      },
      "source": [
        "As you can see, the channel sorting can slightly improve the pruned model's accuracy, but there is still a huge degrade, which is quite common for channel pruning. But luckily, we can perform fine-tuning to recover the accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cXkGH-mAAIKc"
      },
      "outputs": [],
      "source": [
        "num_finetune_epochs = 5\n",
        "optimizer = torch.optim.SGD(pruned_model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)\n",
        "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, num_finetune_epochs)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "best_accuracy = 0\n",
        "for epoch in range(num_finetune_epochs):\n",
        "    train(pruned_model, dataloader['train'], criterion, optimizer, scheduler)\n",
        "    accuracy = evaluate(pruned_model, dataloader['test'])\n",
        "    is_best = accuracy > best_accuracy\n",
        "    if is_best:\n",
        "        best_accuracy = accuracy\n",
        "    print(f'Epoch {epoch+1} Accuracy {accuracy:.2f}% / Best Accuracy: {best_accuracy:.2f}%')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G8L4ICpzN6pS"
      },
      "source": [
        "## Measure acceleration from pruning\n",
        "\n",
        "After fine-tuning, the model almost recovers the accuracy. You may have already learned that channel pruning is usually more difficult to recover accuracy compared to fine-grained pruning. However, it directly leads to a smaller model size and smaller computation without specialized model format. It can also run faster on GPUs. Now we compare the model size, computation, and latency of the pruned model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TF8lXvyeIpTk"
      },
      "outputs": [],
      "source": [
        "# helper functions to measure latency of a regular PyTorch models.\n",
        "#   Unlike fine-grained pruning, channel pruning\n",
        "#   can directly leads to model size reduction and speed up.\n",
        "@torch.no_grad()\n",
        "def measure_latency(model, dummy_input, n_warmup=20, n_test=100):\n",
        "    model.eval()\n",
        "    # warmup\n",
        "    for _ in range(n_warmup):\n",
        "        _ = model(dummy_input)\n",
        "    # real test\n",
        "    t1 = time.time()\n",
        "    for _ in range(n_test):\n",
        "        _ = model(dummy_input)\n",
        "    t2 = time.time()\n",
        "    return (t2 - t1) / n_test  # average latency\n",
        "\n",
        "table_template = \"{:<15} {:<15} {:<15} {:<15}\"\n",
        "print (table_template.format('', 'Original','Pruned','Reduction Ratio'))\n",
        "\n",
        "# 1. measure the latency of the original model and the pruned model on CPU\n",
        "#   which simulates inference on an edge device\n",
        "dummy_input = torch.randn(1, 3, 32, 32).to('cpu')\n",
        "pruned_model = pruned_model.to('cpu')\n",
        "model = model.to('cpu')\n",
        "\n",
        "pruned_latency = measure_latency(pruned_model, dummy_input)\n",
        "original_latency = measure_latency(model, dummy_input)\n",
        "print(table_template.format('Latency (ms)',\n",
        "                            round(original_latency * 1000, 1),\n",
        "                            round(pruned_latency * 1000, 1),\n",
        "                            round(original_latency / pruned_latency, 1)))\n",
        "\n",
        "# 2. measure the computation (MACs)\n",
        "original_macs = get_model_macs(model, dummy_input)\n",
        "pruned_macs = get_model_macs(pruned_model, dummy_input)\n",
        "print(table_template.format('MACs (M)',\n",
        "                            round(original_macs / 1e6),\n",
        "                            round(pruned_macs / 1e6),\n",
        "                            round(original_macs / pruned_macs, 1)))\n",
        "\n",
        "# 3. measure the model size (params)\n",
        "original_param = get_num_parameters(model)\n",
        "pruned_param = get_num_parameters(pruned_model)\n",
        "print(table_template.format('Param (M)',\n",
        "                            round(original_param / 1e6, 2),\n",
        "                            round(pruned_param / 1e6, 2),\n",
        "                            round(original_param / pruned_param, 1)))\n",
        "\n",
        "# put model back to cuda\n",
        "pruned_model = pruned_model.to('cuda')\n",
        "model = model.to('cuda')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TDpOt1WCABWy"
      },
      "source": [
        "### Question 8 (10 pts)\n",
        "\n",
        "Please answer the following questions using the information in the previous code cell.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EZAkttHyZXo1"
      },
      "source": [
        "#### Question 8.1 (5 pts)\n",
        "\n",
        "Explain why removing 30% of channels roughly leads to 50% computation reduction."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qHaBDss2ZYEd"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fqpqToMYZZkX"
      },
      "source": [
        "#### Question 8.2 (5 pts)\n",
        "\n",
        "Explain why the latency reduction ratio is slightly smaller than computation reduction."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UhGuKP9oZa15"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5gGwXyU44pvg"
      },
      "source": [
        "# Compare Fine-grained Pruning and Channel Pruning\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x_onehCuZc91"
      },
      "source": [
        "## Question 9 (10 pts)\n",
        "\n",
        "\n",
        "After all experiments in this lab, you may have become familiar with both fine-grained pruning and channel pruning.\n",
        "\n",
        "Please answer the following questions using what you have learned from the lectures and this lab."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bygFUTmRZeQm"
      },
      "source": [
        "### Question 9.1 (5 pts)\n",
        "\n",
        "What are the advantages and disadvantages of fine-grained pruning and channel pruning? You can discuss from the perspective of compression ratio, accuracy, latency, hardware support (*i.e.*, requiring specialized hardware accelerator), etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bkCGH6dVZfuU"
      },
      "source": [
        "**Your Answer:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VPzfEqAyZhEm"
      },
      "source": [
        "### Question 9.2 (5 pts)\n",
        "\n",
        "If you want to make your model run faster on a smartphone, which pruning method will you use? Why?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BydLPTgCZihp"
      },
      "source": [
        "**Your Answer:**"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "2tFjnZZVlIFL"
      ],
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
